dsh-connect 0.2.0 → 0.5.2

package/lib/runner.js

@@ -5,32 +5,183 @@
  * @module dsh-connect/runner
  */
 import { randomUUID } from "node:crypto";
-import { existsSync, statSync } from "node:fs";
-import { isAbsolute } from "node:path";
+import { existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import { copyFile, readFile } from "node:fs/promises";
+import { basename, isAbsolute, join } from "node:path";
 import { SessionId } from "@deepseek-ai/dsh-session";
-import { installModelSelection } from "@deepseek-ai/dsh-agent";
 import { createUserMessage, ReasoningEffortId } from "@deepseek-ai/dsh-llm";
 import { createAsyncQueue } from "./stream.js";
-import { HELP_TEXT, parseCommand } from "./commands.js";
+import { helpText, parseCommand } from "./commands.js";
+import { messages } from "./i18n.js";
 export function resolveConnectConfig(config) {
     return {
         agentPreset: config.agentPreset,
         workDir: config.workDir,
         workspaces: config.workspaces ?? [],
+        visionModel: config.visionModel,
+        language: config.language ?? "zh",
         allowUsers: config.allowUsers ?? [],
         allowChats: config.allowChats ?? [],
         stateDir: config.stateDir,
+        autoMirror: config.autoMirror ?? true, // Enabled by default
+        streamHeartbeatMs: config.streamHeartbeatMs ?? 60_000,
+        notifyLevel: config.notifyLevel ?? "important",
+        progressTimeoutMs: config.progressTimeoutMs ?? 5 * 60_000, // Proactive progress notice after 5 min of silence
     };
 }
-const REASON_LABELS = {
-    completed: "✅ 完成",
-    aborted: "⏹️ 已中止",
-    blocked: "🚫 阻塞",
-    error: "❌ 出错",
-    "max-tokens": "⚠️ 达到输出上限",
-    interrupted: "⚠️ 被中断",
-    unknown: "❓ 未知",
-};
+/**
+ * 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":
@@ -50,16 +201,44 @@ export function summarizeTurn(events, firstSeq) {
     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)
@@ -68,6 +247,7 @@ export function summarizeTurn(events, firstSeq) {
                 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;
@@ -75,11 +255,31 @@ export function summarizeTurn(events, firstSeq) {
             }
         }
     }
-    return { reason, text, ...(code === undefined ? {} : { code }), ...(message === undefined ? {} : { 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)}…`;
 }
+/** Thousands-separated token count for display. */
+function fmtTokens(n) {
+    return n.toLocaleString("en-US");
+}
 function textOf(message) {
     if (message === undefined)
         return "";
@@ -88,15 +288,58 @@ function textOf(message) {
         .map((b) => b.text ?? "")
         .join("");
 }
-const MENU_TITLES = {
-    root: "主菜单",
-    workspace: "切换工作目录",
-    chat: "切换对话",
-    settings: "设置",
-    model: "切换模型",
-    reasoning: "推理强度",
-    notify: "通知设置",
-};
+/** Lightweight fold of `schedule/change` events (create / delete / dispatch). */
+function foldReminders(events) {
+    const active = new Map();
+    for (const e of events) {
+        // `schedule/change` is a plugin-extended event type outside dsh-session's map.
+        const evt = e;
+        if (evt.type !== "schedule/change")
+            continue;
+        const d = evt.data;
+        if (d.version !== 1)
+            continue;
+        if (d.operation === "create" && d.schedule !== undefined) {
+            active.set(d.schedule.id, {
+                id: d.schedule.id,
+                kind: d.schedule.kind,
+                prompt: d.schedule.prompt,
+                scheduledAt: d.schedule.scheduledAt,
+                everySeconds: d.schedule.everySeconds,
+            });
+        }
+        else if (d.operation === "delete" && d.id !== undefined) {
+            active.delete(d.id);
+        }
+        else if (d.operation === "dispatch" && d.id !== undefined) {
+            const rec = active.get(d.id);
+            if (rec === undefined)
+                continue;
+            if (rec.kind === "every" && rec.everySeconds !== undefined && d.acceptedAt !== undefined) {
+                const next = Date.parse(d.acceptedAt) + rec.everySeconds * 1000;
+                active.set(d.id, { ...rec, scheduledAt: new Date(next).toISOString() });
+            }
+            else {
+                active.delete(d.id);
+            }
+        }
+    }
+    return [...active.values()];
+}
+/** Sniff an image's media type from its magic bytes (defaults to PNG). */
+function detectImageMediaType(buf) {
+    if (buf.length >= 8 && buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47)
+        return "image/png";
+    if (buf.length >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff)
+        return "image/jpeg";
+    if (buf.length >= 12 && buf.toString("ascii", 0, 4) === "RIFF" && buf.toString("ascii", 8, 12) === "WEBP")
+        return "image/webp";
+    if (buf.length >= 6 && buf.toString("ascii", 0, 3) === "GIF")
+        return "image/gif";
+    return "image/png";
+}
+/** How often the proactive progress watchdog re-checks whether a status card is due (ms). */
+const PROGRESS_WATCHDOG_CHECK_MS = 15_000;
 export class AgentRunner {
     ctx;
     config;
@@ -105,6 +348,7 @@ export class AgentRunner {
     chatType;
     adapter;
     bindings;
+    adapters;
     queue = [];
     running = false;
     agent;
@@ -113,7 +357,11 @@ export class AgentRunner {
     workDir;
     streamEnabled = true;
     summaryEnabled = true;
-    constructor(ctx, config, channel, chatKey, chatType, adapter, bindings) {
+    language;
+    notifyLevel;
+    progressTimeoutMs;
+    t;
+    constructor(ctx, config, channel, chatKey, chatType, adapter, bindings, adapters) {
         this.ctx = ctx;
         this.config = config;
         this.channel = channel;
@@ -121,7 +369,62 @@ export class AgentRunner {
         this.chatType = chatType;
         this.adapter = adapter;
         this.bindings = bindings;
+        this.adapters = adapters;
         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);
+        this.language = stored?.language ?? config.language ?? "zh";
+        this.notifyLevel = stored?.notifyLevel ?? config.notifyLevel;
+        this.progressTimeoutMs = stored?.progressTimeoutMs ?? config.progressTimeoutMs;
+        this.t = messages(this.language);
+    }
+    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;
+        }
+    }
+    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 },
+        ];
+    }
+    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;
+        }
     }
     /** Prefer the user's first DSH workspace over the process cwd as default. */
     resolveDefaultWorkDir() {
@@ -149,14 +452,37 @@ export class AgentRunner {
             return;
         if (event.type === "assistant/chunk") {
             const chunk = event.data.chunk;
-            if (chunk.type === "text-delta") {
-                turn.chunks.push(chunk.text);
-                turn.lastText += chunk.text;
+            // First reasoning delta = the milestone the proactive progress notice reports.
+            if (chunk.type === "reasoning-delta" && turn.milestone === undefined) {
+                turn.milestone = this.t.progressThinking;
             }
-            else if (chunk.type === "reasoning-delta" && !turn.reasoning) {
-                turn.reasoning = true;
-                turn.chunks.push("🤔 深度思考中…\n");
+            applyStreamChunk(turn, this.t.thinkingHint, chunk, this.notifyLevel);
+            return;
+        }
+        if (event.type === "tool/call") {
+            const name = event.data.name;
+            if (typeof name !== "string" || name === "")
+                return;
+            const summary = toolCallSummary(event.data.arguments);
+            // The proactive progress notice reports the latest milestone even when
+            // `result` mode hides the streaming details.
+            if (name === "ask_user_question") {
+                const question = questionTextOf(event.data.arguments);
+                turn.milestone = this.t.questionToolCall(question);
             }
+            else {
+                turn.milestone = this.t.toolCalling(name, undefined);
+            }
+            // `result` mode shows nothing until the final answer; `important` shows
+            // the tool name only, `full` also carries the one-line summary.
+            if (this.notifyLevel === "result")
+                return;
+            const label = name === "ask_user_question"
+                ? this.t.questionToolCall(questionTextOf(event.data.arguments))
+                : this.notifyLevel === "full"
+                    ? this.t.toolCalling(name, summary)
+                    : this.t.toolCalling(name, undefined);
+            applyToolCall(turn, label);
         }
     }
     target(msg) {
@@ -183,18 +509,51 @@ export class AgentRunner {
         }
     }
     async runTurn(msg) {
+        // Check session lock - only allow if this channel owns the lock or no lock exists
+        const currentChannel = this.channel === "feishu" ? "feishu" : "web";
+        // Check timeout before attempting to acquire
+        this.checkAndReleaseTimeoutLock();
+        if (!this.acquireLock(currentChannel)) {
+            const binding = this.bindings.get(this.channel, this.chatKey);
+            const lockedBy = binding?.lockOwner ?? "unknown";
+            // If from Web channel, queue the message instead of rejecting
+            if (currentChannel === "web") {
+                const position = this.queueMessage(msg);
+                await this.adapter
+                    .sendText(this.target(msg), this.t.messageQueued(position))
+                    .catch(() => undefined);
+            }
+            else {
+                // Feishu gets immediate feedback
+                await this.adapter
+                    .sendText(this.target(msg), this.t.sessionLockedBy(lockedBy))
+                    .catch(() => undefined);
+            }
+            return;
+        }
         try {
+            // Acknowledge receipt before the (possibly slow) agent spin-up so the
+            // user knows processing started.
+            await this.adapter
+                .sendText(this.target(msg), this.t.processingStarted(truncate(msg.text, 60)))
+                .catch(() => undefined);
             const agent = await this.ensureAgent(msg);
             const outcome = await this.driveAgent(agent, msg);
             this.touchBinding(msg);
+            // Task-end stats: model, tokens, elapsed, and a compaction suggestion.
+            await this.sendTurnStats(msg, outcome);
+            // Release lock after task completion
+            this.releaseLock();
             if (outcome.reason !== "completed" && this.summaryEnabled) {
                 await this.sendSummary(msg, outcome);
             }
         }
         catch (error) {
+            // Release lock even on error
+            this.releaseLock();
             const detail = error instanceof Error ? error.message : String(error);
             await this.adapter
-                .sendText(this.target(msg), `⚠️ 处理失败：${truncate(detail)}`)
+                .sendText(this.target(msg), this.t.processingFailed(truncate(detail)))
                 .catch(() => undefined);
         }
     }
@@ -204,6 +563,10 @@ export class AgentRunner {
         const live = binding === undefined ? undefined : this.agents.get(SessionId(binding.sessionId));
         if (live !== undefined) {
             this.agent = live;
+            // The live agent may have been recreated outside the runner (e.g. by
+            // the Web GUI's api-proxy) since we last saw it — make sure we are
+            // listening to the current instance so streaming can't silently die.
+            this.watchAgent(live);
             return live;
         }
         const selection = this.defaultSelection();
@@ -218,6 +581,10 @@ export class AgentRunner {
                 this.handle = handle;
                 this.agent = handle.agent;
                 this.watchAgent(handle.agent);
+                // Ensure Web mirror exists for resumed sessions
+                this.autoCreateWebMirror(binding.sessionId, msg.senderKey);
+                // Ensure the session shows up under its workspace in the Web GUI
+                void this.attachToWorkspace(binding.sessionId);
                 return handle.agent;
             }
             catch (error) {
@@ -238,8 +605,29 @@ export class AgentRunner {
         this.agent = handle.agent;
         this.watchAgent(handle.agent);
         this.recordSession(String(sessionId), truncate(msg.text, 40), msg.senderKey);
+        // Auto-create Web mirror for new sessions (if enabled)
+        this.autoCreateWebMirror(String(sessionId), msg.senderKey);
+        // Ensure the new session shows up under its workspace in the Web GUI
+        void this.attachToWorkspace(String(sessionId));
         return handle.agent;
     }
+    /**
+     * Attach a session to the DSH workspace matching its work directory so the
+     * Web GUI groups it under the same workspace the Feishu side uses.
+     * Best-effort: without a workspace registry this is a no-op.
+     */
+    async attachToWorkspace(sessionId) {
+        const registry = this.ctx.get("workspaceRegistry");
+        if (registry?.resolveByPath === undefined)
+            return;
+        try {
+            const ws = await registry.resolveByPath(this.workDir);
+            await ws?.attachSession?.(sessionId);
+        }
+        catch (error) {
+            this.log(`connect: attachToWorkspace(${sessionId}) skipped: ${String(error)}`);
+        }
+    }
     // Service lookups must go through ctx.get(): property access (ctx.agents) is
     // fiber-scoped and rejected from the async Feishu callback with "without inject".
     get agents() {
@@ -252,37 +640,58 @@ export class AgentRunner {
         const service = this.ctx.get("agentDefaultModel");
         return service?.currentSelection?.() ?? { provider: "", model: "" };
     }
-    async composeSetup(selection) {
+    /**
+     * Compose the preset-only agent setup.
+     *
+     * Deliberately does NOT install a static model selection on the agent. The
+     * DSH Web GUI switches models through the host api-proxy's session-scoped
+     * selection (`selectionFor` + `installModelSelection`), which is installed
+     * lazily when a session's model directory is loaded and wins the
+     * `agent/request` waterfall. A static selection captured here at create /
+     * resume time would take precedence over that and silently pin every request
+     * to the default model captured at composition — so a model the user picks
+     * in the Web GUI would appear to succeed (the seat and `session.models`
+     * report it) while the actual LLM requests keep using the old default.
+     * The default model still seeds the agent through `agentOptions` in
+     * `ensureAgent`, which `buildRequest` uses as its fallback route.
+     */
+    async composeSetup(_selection) {
         const presets = this.ctx.get("agentPresets");
         if (presets === undefined) {
             return {
-                setup: (agentCtx) => {
-                    installModelSelection(agentCtx, { current: selection, assembled: undefined });
-                },
+                setup: () => undefined,
             };
         }
         const resolved = await presets.resolve(this.config.agentPreset);
         return {
             agentPreset: resolved.id,
             setup: async (agentCtx) => {
-                installModelSelection(agentCtx, { current: selection, assembled: undefined });
                 await presets.mount(agentCtx, resolved.id);
             },
         };
     }
+    /** Agents this runner has already attached a `session/event` listener to. */
+    watchedAgents = new WeakSet();
     watchAgent(agent) {
-        // Scope-filtered: receives only this agent's session events.
+        // Scope-filtered: receives only this agent's session events. Deduplicated
+        // by object so a re-resumed agent (possibly recreated outside the runner,
+        // e.g. by the Web GUI's api-proxy) is re-watched without double-firing on
+        // a still-live agent.
+        if (this.watchedAgents.has(agent))
+            return;
+        this.watchedAgents.add(agent);
         agent.ctx.on("session/event", (session, event) => {
             this.onSessionEvent(session, event);
         });
     }
     async driveAgent(agent, msg) {
         const firstSeq = agent.session.seq;
+        const userMessage = async () => {
+            const content = await this.buildUserContent(msg);
+            return createUserMessage({ content, source: { kind: "user" } });
+        };
         if (!this.streamEnabled) {
-            agent.followup(createUserMessage({
-                content: [{ type: "text", text: msg.text }],
-                source: { kind: "user" },
-            }));
+            agent.followup(await userMessage());
             await agent.whenIdle();
             await this.sessions.flush(agent.session);
             const outcome = summarizeTurn(agent.session.events, firstSeq);
@@ -292,21 +701,288 @@ export class AgentRunner {
             return outcome;
         }
         const chunks = createAsyncQueue();
-        this.turn = { firstSeq, chunks, lastText: "", reasoning: false };
-        const streamPromise = this.adapter.streamText(this.target(msg), chunks);
-        agent.followup(createUserMessage({
-            content: [{ type: "text", text: msg.text }],
-            source: { kind: "user" },
-        }));
-        await agent.whenIdle();
-        await this.sessions.flush(agent.session);
-        chunks.end();
-        await streamPromise;
+        const now = Date.now();
+        this.turn = {
+            firstSeq, chunks, lastText: "",
+            reasoning: false, hintPushed: false, lastIndex: undefined, pushedAny: false,
+            startedAt: now, lastPushAt: now,
+        };
+        // Liveness heartbeat: while the agent is working, keep the streaming card
+        // visibly alive even through long reasoning or tool-execution stretches
+        // (a card that sits on "Thinking…" for minutes looks frozen). Configurable
+        // via `streamHeartbeatMs`; 0 disables it.
+        const heartbeatMs = this.config.streamHeartbeatMs;
+        const heartbeat = heartbeatMs > 0 && this.notifyLevel !== "result"
+            ? setInterval(() => {
+                const turn = this.turn;
+                if (turn === undefined)
+                    return;
+                const elapsed = Date.now() - turn.lastPushAt;
+                if (elapsed < heartbeatMs)
+                    return;
+                turn.lastPushAt = Date.now();
+                const minutes = Math.max(1, Math.round((turn.lastPushAt - turn.startedAt) / 60_000));
+                turn.chunks.push(`\n\n${this.t.processingHeartbeat(minutes)}\n\n`);
+            }, 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.
+        const progressTimeoutMs = this.progressTimeoutMs;
+        let lastStandaloneNoticeAt = now;
+        const progressWatchdog = progressTimeoutMs > 0
+            ? setInterval(() => {
+                const turn = this.turn;
+                if (turn === undefined)
+                    return;
+                const elapsed = Date.now() - lastStandaloneNoticeAt;
+                if (elapsed < progressTimeoutMs)
+                    return;
+                lastStandaloneNoticeAt = 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);
+            }, PROGRESS_WATCHDOG_CHECK_MS)
+            : undefined;
+        try {
+            const streamPromise = this.adapter.streamText(this.target(msg), chunks);
+            agent.followup(await userMessage());
+            await agent.whenIdle();
+            await this.sessions.flush(agent.session);
+            chunks.end();
+            await streamPromise;
+        }
+        finally {
+            if (heartbeat !== undefined)
+                clearInterval(heartbeat);
+            if (progressWatchdog !== undefined)
+                clearInterval(progressWatchdog);
+        }
         const outcome = summarizeTurn(agent.session.events, firstSeq);
         const text = outcome.text !== "" ? outcome.text : this.turn.lastText;
         this.turn = undefined;
         return { ...outcome, text };
     }
+    /**
+     * Build the user content for one inbound message. When the message carries
+     * images, either pass them directly to the main model (if it supports
+     * vision) or run a vision sub-task with a capable model and inject its
+     * description as text — so a text-only main model never stalls on images.
+     */
+    async buildUserContent(msg) {
+        const content = [{ type: "text", text: msg.text }];
+        const rawImages = msg.images;
+        if (rawImages === undefined || rawImages.length === 0) {
+            if (msg.imageError !== undefined) {
+                content.push({ type: "text", text: this.t.imageDownloadFailed(msg.imageError) });
+            }
+            return content;
+        }
+        // Copy images into the agent's work directory so its tools can access them.
+        const paths = await this.stageImages(rawImages);
+        const locationText = paths.map((p) => `- ${p}`).join("\n");
+        const mainVision = await this.modelSupportsVision(this.agent?.options.provider, this.agent?.options.model);
+        if (mainVision) {
+            const imageBlocks = await this.imageBlocks(paths);
+            if (imageBlocks.length > 0) {
+                this.log(`connect: main model supports vision — passing ${imageBlocks.length} image block(s) directly`);
+                return [{ type: "text", text: msg.text }, ...imageBlocks];
+            }
+            this.log("connect: main model supports vision but image blocks failed to attach — falling back to paths");
+            return content;
+        }
+        const description = await this.describeImages(paths);
+        const note = this.t.imagesStaged(locationText, description);
+        content.push({ type: "text", text: note });
+        // Non-image attachments (files / audio / video): stage them into the work
+        // directory and hand the agent the paths — it can open them with its tools.
+        const rawFiles = msg.files;
+        if (rawFiles !== undefined && rawFiles.length > 0) {
+            const stagedFiles = await this.stageFiles(rawFiles);
+            content.push({
+                type: "text",
+                text: this.t.filesStaged(stagedFiles.length, stagedFiles.map((p) => `- ${p}`).join("\n")),
+            });
+        }
+        if (msg.fileError !== undefined) {
+            content.push({ type: "text", text: this.t.fileDownloadFailed(msg.fileError) });
+        }
+        return content;
+    }
+    /** Copy images into `<workDir>/.dsh-connect-images` so the agent's tools can reach them. */
+    async stageImages(paths) {
+        const dir = join(this.workDir, ".dsh-connect-images");
+        try {
+            mkdirSync(dir, { recursive: true });
+        }
+        catch {
+            return [...paths];
+        }
+        const staged = [];
+        for (const p of paths) {
+            const target = join(dir, basename(p));
+            try {
+                await copyFile(p, target);
+                staged.push(target);
+            }
+            catch {
+                staged.push(p);
+            }
+        }
+        return staged;
+    }
+    /** Copy non-image attachments into `<workDir>/.dsh-connect-files` so the agent's tools can reach them. */
+    async stageFiles(paths) {
+        const dir = join(this.workDir, ".dsh-connect-files");
+        try {
+            mkdirSync(dir, { recursive: true });
+        }
+        catch {
+            return [...paths];
+        }
+        const staged = [];
+        for (const p of paths) {
+            const target = join(dir, basename(p));
+            try {
+                await copyFile(p, target);
+                staged.push(target);
+            }
+            catch {
+                staged.push(p);
+            }
+        }
+        return staged;
+    }
+    async imageBlocks(paths) {
+        const attachments = this.ctx.get("attachments");
+        if (attachments?.saveImage === undefined)
+            return [];
+        const blocks = [];
+        for (const path of paths) {
+            try {
+                const buf = await readFile(path);
+                const mediaType = detectImageMediaType(buf);
+                const ref = await attachments.saveImage({ data: new Uint8Array(buf), mediaType });
+                blocks.push({ type: "image", attachment: ref });
+            }
+            catch {
+                // Skip unreadable / unsupported images.
+            }
+        }
+        return blocks;
+    }
+    async describeImages(paths) {
+        const vision = await this.findVisionModel();
+        if (vision === null) {
+            this.log("connect: describeImages skipped — no vision model available");
+            return "";
+        }
+        const attachments = this.ctx.get("attachments");
+        const llm = this.ctx.get("llm");
+        if (attachments?.saveImage === undefined || llm?.stream === undefined) {
+            this.log(`connect: describeImages skipped — attachments.saveImage=${attachments?.saveImage !== undefined}, llm.stream=${llm?.stream !== undefined}`);
+            return "";
+        }
+        const refs = [];
+        for (const path of paths) {
+            try {
+                const buf = await readFile(path);
+                refs.push(await attachments.saveImage({ data: new Uint8Array(buf), mediaType: detectImageMediaType(buf) }));
+            }
+            catch (error) {
+                this.log(`connect: saveImage failed for ${path}: ${String(error)}`);
+            }
+        }
+        if (refs.length === 0) {
+            this.log("connect: describeImages skipped — no image could be attached");
+            return "";
+        }
+        this.log(`connect: describing ${refs.length} image(s) with ${vision.provider}/${vision.model}`);
+        const messages = [
+            {
+                role: "user",
+                content: [
+                    { type: "text", text: this.t.visionPrompt },
+                    ...refs.map((ref) => ({ type: "image", attachment: ref })),
+                ],
+            },
+        ];
+        try {
+            let text = "";
+            const stream = llm.stream({ provider: vision.provider, model: vision.model, messages, maxTokens: 2048 });
+            for await (const chunk of stream) {
+                if (chunk.type === "text-delta" && typeof chunk.text === "string")
+                    text += chunk.text;
+            }
+            this.log(`connect: vision description produced ${text.length} char(s)`);
+            return text.trim();
+        }
+        catch (error) {
+            this.log(`connect: vision description call failed: ${error instanceof Error ? error.message : String(error)}`);
+            return "";
+        }
+    }
+    async modelSupportsVision(provider, model) {
+        if (provider === undefined || model === undefined)
+            return false;
+        const llm = this.ctx.get("llm");
+        try {
+            const info = await llm?.resolveModelInfo?.(provider, model);
+            const supports = info?.inputModalities?.includes("image") ?? false;
+            this.log(`connect: main model vision check ${provider}/${model} -> ${supports} (inputModalities=${JSON.stringify(info?.inputModalities)})`);
+            return supports;
+        }
+        catch (error) {
+            this.log(`connect: main model vision check ${provider}/${model} failed: ${String(error)}`);
+            return false;
+        }
+    }
+    async findVisionModel() {
+        if (this.config.visionModel !== undefined) {
+            this.log(`connect: vision model configured: ${this.config.visionModel.provider}/${this.config.visionModel.model}`);
+            return this.config.visionModel;
+        }
+        const llm = this.ctx.get("llm");
+        if (llm?.listProviders === undefined || llm.resolveModelInfo === undefined) {
+            this.log("connect: vision auto-detection unavailable — llm service lacks listProviders/resolveModelInfo");
+            return null;
+        }
+        const providers = llm.listProviders() ?? [];
+        this.log(`connect: vision auto-detection scanning ${providers.length} provider(s): ${providers.map((p) => p.id).join(", ") || "(none)"}`);
+        for (const p of providers) {
+            let models = [];
+            try {
+                models = (await llm.listModels?.(p.id)) ?? [];
+            }
+            catch (error) {
+                this.log(`connect: listModels(${p.id}) failed: ${String(error)}`);
+                continue;
+            }
+            this.log(`connect: provider ${p.id} advertises ${models.length} model(s)`);
+            for (const m of models) {
+                try {
+                    const info = await llm.resolveModelInfo(p.id, m.id);
+                    this.log(`connect:   ${p.id}/${m.id} inputModalities=${JSON.stringify(info.inputModalities)}`);
+                    if (info.inputModalities?.includes("image")) {
+                        this.log(`connect: vision model selected: ${p.id}/${m.id}`);
+                        return { provider: p.id, model: m.id };
+                    }
+                }
+                catch (error) {
+                    this.log(`connect:   resolveModelInfo(${p.id}/${m.id}) failed: ${String(error)}`);
+                }
+            }
+        }
+        this.log("connect: no image-capable model found via auto-detection");
+        return null;
+    }
+    log(message) {
+        this.ctx.get("logger")?.info?.(message);
+    }
     readTodos() {
         const agent = this.agent;
         if (agent === undefined)
@@ -326,13 +1002,42 @@ export class AgentRunner {
         this.bindings.put({ ...binding, ownerKey: msg.senderKey, lastActiveAt: Date.now() });
     }
     async sendSummary(msg, outcome) {
-        const lines = [`**任务结束**：${REASON_LABELS[outcome.reason]}`];
+        const lines = [this.t.taskEnded(this.reasonLabel(outcome.reason))];
         if (outcome.code !== undefined)
-            lines.push(`错误码：\`${outcome.code}\``);
+            lines.push(this.t.errorCode(outcome.code));
         if (outcome.message !== undefined)
-            lines.push(`原因：${truncate(outcome.message)}`);
+            lines.push(this.t.reasonMessage(truncate(outcome.message)));
         if (outcome.text !== "")
-            lines.push(`已产出：${truncate(outcome.text, 300)}`);
+            lines.push(this.t.produced(truncate(outcome.text, 300)));
+        const card = { markdown: lines.join("\n") };
+        await this.adapter.sendCard(this.target(msg), card).catch(() => undefined);
+    }
+    /** Context-window usage at or above this percentage suggests compaction. */
+    static COMPACT_THRESHOLD_PCT = 75;
+    /**
+     * Send a compact task-end card: the model used, input/output tokens, elapsed
+     * time, and whether compaction is advisable given context-window usage.
+     */
+    async sendTurnStats(msg, outcome) {
+        if (outcome.model === undefined && outcome.inputTokens === undefined && outcome.outputTokens === undefined)
+            return;
+        const lines = [
+            this.t.taskStatsHeader(outcome.elapsedMs === undefined ? "—" : this.t.taskDuration(outcome.elapsedMs)),
+        ];
+        if (outcome.model !== undefined)
+            lines.push(this.t.taskStatsModel(outcome.model));
+        if (outcome.inputTokens !== undefined) {
+            lines.push(this.t.taskStatsTokensIn(fmtTokens(outcome.inputTokens), outcome.cacheReadTokens !== undefined ? fmtTokens(outcome.cacheReadTokens) : undefined));
+        }
+        if (outcome.outputTokens !== undefined)
+            lines.push(this.t.taskStatsTokensOut(fmtTokens(outcome.outputTokens)));
+        if (outcome.steps !== undefined)
+            lines.push(this.t.taskStatsSteps(outcome.steps));
+        if (outcome.contextSize !== undefined && outcome.contextWindow !== undefined && outcome.contextWindow > 0) {
+            const pct = Math.round((outcome.contextSize / outcome.contextWindow) * 100);
+            lines.push(this.t.taskStatsContext(`${pct}`, fmtTokens(outcome.contextWindow)));
+            lines.push(pct >= AgentRunner.COMPACT_THRESHOLD_PCT ? this.t.taskStatsCompactSuggest : this.t.taskStatsCompactOk);
+        }
         const card = { markdown: lines.join("\n") };
         await this.adapter.sendCard(this.target(msg), card).catch(() => undefined);
     }
@@ -341,17 +1046,17 @@ export class AgentRunner {
         switch (command.kind) {
             case "new": {
                 await this.newChat(msg);
-                await this.adapter.sendText(target, "已开启新会话。");
+                await this.adapter.sendText(target, this.t.newChatDone);
                 break;
             }
             case "clear": {
                 await this.clearChat(msg);
-                await this.adapter.sendText(target, "会话已清空。");
+                await this.adapter.sendText(target, this.t.chatCleared);
                 break;
             }
             case "stop": {
                 this.agent?.cancel({ kind: "user" });
-                await this.adapter.sendText(target, "已请求停止当前任务。");
+                await this.adapter.sendText(target, this.t.stopRequested);
                 break;
             }
             case "status": {
@@ -369,22 +1074,22 @@ export class AgentRunner {
                 }
                 const path = command.path;
                 if (!isAbsolute(path)) {
-                    await this.adapter.sendText(target, "请输入绝对路径，例如 `/dir D:\\projects\\my-app`。");
+                    await this.adapter.sendText(target, this.t.dirUsage);
                     break;
                 }
                 try {
                     if (!existsSync(path) || !statSync(path).isDirectory()) {
-                        await this.adapter.sendText(target, `目录不存在或不是文件夹：${path}`);
+                        await this.adapter.sendText(target, this.t.dirNotExists(path));
                         break;
                     }
                 }
                 catch {
-                    await this.adapter.sendText(target, `无法访问目录：${path}`);
+                    await this.adapter.sendText(target, this.t.dirUnreadable(path));
                     break;
                 }
                 this.workDir = path;
                 await this.newChat(msg);
-                await this.adapter.sendText(target, `工作目录已切换为：\n${path}\n（已开启新会话）`);
+                await this.adapter.sendText(target, this.t.dirSwitched(path));
                 break;
             }
             case "chat": {
@@ -405,7 +1110,7 @@ export class AgentRunner {
             }
             case "workspace": {
                 if (command.path === undefined) {
-                    await this.adapter.sendText(target, "用法：`/workspace <绝对路径>`，例如 `/workspace D:\\projects\\new-app`。");
+                    await this.adapter.sendText(target, this.t.workspaceUsage);
                     break;
                 }
                 await this.createWorkspace(command.path, target);
@@ -423,16 +1128,44 @@ export class AgentRunner {
                 await this.showGoals(target);
                 break;
             }
+            case "schedule": {
+                await this.showSchedule(target);
+                break;
+            }
             case "model": {
                 await this.openMenu(target, msg, "model", ["root"]);
                 break;
             }
+            case "notify": {
+                await this.openNotifyPicker(target, msg);
+                break;
+            }
+            case "progress": {
+                await this.openProgressPicker(target, msg);
+                break;
+            }
             case "workspaces": {
                 await this.showAllWorkspaces(target);
                 break;
             }
+            case "mirror": {
+                await this.handleMirror(target, msg);
+                break;
+            }
+            case "unlock": {
+                await this.handleUnlock(target);
+                break;
+            }
+            case "renew": {
+                await this.handleRenewLock(target);
+                break;
+            }
+            case "export": {
+                await this.handleExport(target, command.format);
+                break;
+            }
             case "help": {
-                await this.adapter.sendText(target, HELP_TEXT);
+                await this.adapter.sendText(target, helpText(this.t));
                 break;
             }
             default:
@@ -469,6 +1202,37 @@ export class AgentRunner {
             sessions,
         });
     }
+    /**
+     * Automatically create a Web mirror for the session.
+     * This enables DSH Web GUI to view and interact with the conversation
+     * without requiring manual `/mirror` command.
+     */
+    autoCreateWebMirror(sessionId, ownerKey) {
+        // Check if auto-mirror is enabled in config
+        if (!this.config.autoMirror)
+            return;
+        // Only auto-create for Feishu channel (not for Web itself)
+        if (this.channel !== "feishu")
+            return;
+        const binding = this.bindings.get(this.channel, this.chatKey);
+        if (binding === undefined)
+            return;
+        // Check if mirror already exists
+        if (binding.webMirrorSessionId !== undefined) {
+            return; // Mirror already configured
+        }
+        // Auto-create mirror with default settings
+        const defaultTimeoutMs = 5 * 60 * 1000; // 5 minutes
+        this.bindings.put({
+            ...binding,
+            webMirrorSessionId: sessionId,
+            lockOwner: "feishu", // Feishu owns the lock initially
+            lockAcquiredAt: Date.now(),
+            lockTimeoutMs: defaultTimeoutMs,
+            lastActiveAt: Date.now(),
+        });
+        this.log(`connect: auto-created Web mirror for session ${sessionId}`);
+    }
     async newChat(msg) {
         await this.disposeAgent();
         const binding = this.bindings.get(this.channel, this.chatKey);
@@ -506,7 +1270,7 @@ export class AgentRunner {
             seen.add(key);
             out.push({ path, title: title || path });
         };
-        add(this.workDir, "当前目录");
+        add(this.workDir, this.t.currentDir);
         for (const w of registry?.list?.() ?? [])
             add(w.path, w.title);
         for (const p of this.config.workspaces)
@@ -516,14 +1280,22 @@ export class AgentRunner {
     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: "❌ 退出" });
+        options.push({ id: "menu:exit", label: this.t.menuExit });
         if (stack.length > 0)
-            options.push({ id: "menu:back", label: "🔙 返回" });
-        const { choice, messageId } = await this.adapter.promptChoice(target, { title: MENU_TITLES[menuId], options }, cardId);
+            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, "菜单已关闭。");
+            await this.adapter.closeMenu(messageId, this.t.menuClosed);
             return;
         }
         if (choice === "menu:back") {
@@ -544,15 +1316,16 @@ export class AgentRunner {
         switch (menuId) {
             case "root":
                 return [
-                    { id: "workspace", label: "📁 切换工作目录", onSelect: (t, m, cardId) => this.openMenu(t, m, "workspace", ["root"], cardId) },
-                    { id: "chat", label: "💬 切换对话", onSelect: (t, m, cardId) => this.openMenu(t, m, "chat", ["root"], cardId) },
-                    { id: "status", label: "📊 查看状态", leaf: true, onSelect: async (t) => { await this.showStatus(t); } },
-                    { id: "task", label: "📋 查看任务", leaf: true, onSelect: async (t) => { await this.showTasks(t); } },
-                    { id: "history", label: "🗒️ 历史消息", leaf: true, onSelect: async (t) => { await this.showHistory(t, 10); } },
-                    { id: "goals", label: "🎯 目标", leaf: true, onSelect: async (t) => { await this.showGoals(t); } },
-                    { id: "compact", label: "🗜️ 压缩上下文", leaf: true, onSelect: async (t) => { await this.compact(t); } },
-                    { id: "plugins", label: "🔌 查看插件", leaf: true, onSelect: async (t) => { await this.showPlugins(t); } },
-                    { id: "settings", label: "⚙️ 设置", onSelect: (t, m, cardId) => this.openMenu(t, m, "settings", ["root"], cardId) },
+                    { 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();
@@ -570,17 +1343,24 @@ export class AgentRunner {
                 const binding = this.bindings.get(this.channel, this.chatKey);
                 const sessions = binding?.sessions ?? [];
                 const active = binding?.sessionId;
-                const items = sessions.map((s) => ({
-                    id: `session:${s.sessionId}`,
-                    label: `${s.sessionId === active ? "●" : "○"} ${s.title || s.sessionId}`,
-                    leaf: true,
-                    onSelect: async (t, m) => {
-                        await this.switchTo(s.sessionId, m.senderKey);
-                    },
-                }));
+                const hasWebMirror = binding?.webMirrorSessionId !== undefined;
+                const items = sessions.map((s) => {
+                    // Check if this session is mirrored to Web
+                    const isMirrored = hasWebMirror && binding.webMirrorSessionId === s.sessionId;
+                    const mirrorIndicator = isMirrored ? ` ${this.t.webMirrorIndicator}` : "";
+                    const activeIndicator = s.sessionId === active ? "●" : "○";
+                    return {
+                        id: `session:${s.sessionId}`,
+                        label: `${activeIndicator} ${s.title || s.sessionId}${mirrorIndicator}`,
+                        leaf: true,
+                        onSelect: async (t, m) => {
+                            await this.switchTo(s.sessionId, m.senderKey);
+                        },
+                    };
+                });
                 items.push({
                     id: "action:new",
-                    label: "➕ 新建对话",
+                    label: this.t.menuNewChat,
                     leaf: true,
                     onSelect: async (t, m) => {
                         await this.newChat(m);
@@ -590,63 +1370,141 @@ export class AgentRunner {
             }
             case "settings":
                 return [
-                    { id: "model", label: "🤖 切换模型", onSelect: (t, m, cardId) => this.openMenu(t, m, "model", ["settings", "root"], cardId) },
-                    { id: "reasoning", label: "🧠 推理强度", onSelect: (t, m, cardId) => this.openMenu(t, m, "reasoning", ["settings", "root"], cardId) },
-                    { id: "notify", label: "🔔 通知设置", onSelect: (t, m, cardId) => this.openMenu(t, m, "notify", ["settings", "root"], cardId) },
-                    { id: "overview", label: "📄 配置总览", leaf: true, onSelect: async (t) => { await this.showSettings(t); } },
+                    { 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 "model":
-                return await this.modelMenuItems();
-            case "reasoning":
-                return this.reasoningMenuItems();
-            case "notify":
+            case "language":
                 return [
                     {
-                        id: "stream",
-                        label: `流式输出：${this.streamEnabled ? "开" : "关"}`,
+                        id: "lang:zh",
+                        label: `${this.language === "zh" ? "● " : ""}${this.t.languageZh}`,
                         leaf: true,
-                        onSelect: async () => {
-                            this.streamEnabled = !this.streamEnabled;
-                        },
+                        onSelect: async (t, m) => { await this.setLanguage("zh", t, m); },
                     },
                     {
-                        id: "summary",
-                        label: `结束摘要：${this.summaryEnabled ? "开" : "关"}`,
+                        id: "lang:en",
+                        label: `${this.language === "en" ? "● " : ""}${this.t.languageEn}`,
                         leaf: true,
-                        onSelect: async () => {
-                            this.summaryEnabled = !this.summaryEnabled;
-                        },
+                        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);
+                    },
+                }));
+            }
         }
     }
     async showStatus(target) {
         const agent = this.agent;
         if (agent === undefined) {
-            await this.adapter.sendText(target, `状态：无活动会话\n工作目录：${this.workDir}`);
+            await this.adapter.sendText(target, this.t.statusNoSession(this.workDir));
             return;
         }
-        const label = agent.status === "running" ? "🟢 运行中" : "⚪ 空闲";
+        // Determine detailed execution state
+        let statusLabel;
+        if (agent.status === "running") {
+            statusLabel = this.t.statusExecuting;
+        }
+        else if (this.queue.length > 0) {
+            statusLabel = this.t.statusWaiting;
+        }
+        else {
+            statusLabel = this.t.statusIdle;
+        }
         const model = `${agent.options.provider ?? "-"}/${agent.options.model ?? "-"}`;
-        await this.adapter.sendText(target, [
-            `状态：${label}`,
-            `模型：${model}`,
-            `工作目录：${this.workDir}`,
-            `待处理消息：${this.queue.length}`,
-            `会话：${agent.id}`,
-        ].join("\n"));
+        const lines = [
+            this.t.statusField(statusLabel),
+            this.t.modelField(model),
+            this.t.workdirField(this.workDir),
+        ];
+        // Queue status with detail
+        if (this.queue.length === 0) {
+            lines.push(`${this.t.queuedField(0)} ${this.t.queueEmpty}`);
+        }
+        else {
+            lines.push(`${this.t.queuedField(this.queue.length)} ${this.t.queueDetail(this.queue.length)}`);
+        }
+        // Last turn completion info
+        const lastTurn = this.getLastTurnInfo(agent);
+        if (lastTurn !== undefined) {
+            lines.push(this.t.lastTurnReason(this.reasonLabel(lastTurn.reason)));
+            lines.push(this.t.lastTurnTime(lastTurn.completedAt));
+        }
+        else {
+            lines.push(this.t.noTurnHistory);
+        }
+        lines.push(this.t.sessionField(agent.id));
+        const tokenMeter = this.ctx.get("tokenMeter");
+        try {
+            const m = tokenMeter?.measure?.(agent.session);
+            if (m !== undefined)
+                lines.push(this.t.contextField(m.totalTokens, m.surfaceTokens));
+        }
+        catch {
+            // Token meter unavailable: skip.
+        }
+        await this.adapter.sendText(target, lines.join("\n"));
+    }
+    /** Extract the most recent turn's completion info from session events. */
+    getLastTurnInfo(agent) {
+        const events = agent.session.events;
+        for (let i = events.length - 1; i >= 0; i--) {
+            const event = events[i];
+            if (event.type === "turn/end") {
+                const reason = mapReason(event.data.reason.kind);
+                // Use the event's timestamp if available, otherwise approximate
+                const completedAt = new Date().toLocaleTimeString("zh-CN", { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+                return { reason, completedAt };
+            }
+        }
+        return undefined;
     }
     async showTasks(target) {
         const todos = this.readTodos();
         if (todos.length === 0) {
-            await this.adapter.sendText(target, "当前没有任务清单。");
+            await this.adapter.sendText(target, this.t.noTodos);
             return;
         }
         const lines = todos.map((todo) => {
             const mark = todo.status === "completed" ? "✅" : todo.status === "in_progress" ? "🔄" : "⬜";
             return `${mark} ${todo.content}`;
         });
-        await this.adapter.sendText(target, `当前任务（${todos.length} 项）：\n${lines.join("\n")}`);
+        await this.adapter.sendText(target, this.t.currentTodos(todos.length, lines.join("\n")));
     }
     async showSettings(target) {
         const binding = this.bindings.get(this.channel, this.chatKey);
@@ -654,21 +1512,22 @@ export class AgentRunner {
         const model = agent ? `${agent.options.provider ?? "-"}/${agent.options.model ?? "-"}` : "-";
         const sel = this.defaultSelection();
         const lines = [
-            "⚙️ 设置：",
-            `模型：${model}`,
-            `推理强度：${sel.reasoningEffort ?? "默认"}`,
-            `Agent 预设：${this.config.agentPreset ?? "默认"}`,
-            `工作目录：${this.workDir}`,
-            `工作区列表：${this.config.workspaces.length === 0 ? "（未配置）" : ""}`,
+            this.t.settingsHeader,
+            this.t.modelSetting(model),
+            this.t.reasoningSetting(sel.reasoningEffort ?? this.t.effortDefault),
+            this.t.agentPresetSetting(this.config.agentPreset ?? this.t.defaultLabel),
+            this.t.workdirSetting(this.workDir),
+            this.t.workspacesSetting + (this.config.workspaces.length === 0 ? this.t.notConfigured : ""),
         ];
         for (const w of this.config.workspaces)
             lines.push(`  - ${w}`);
-        lines.push(`对话数：${binding?.sessions.length ?? 0}`);
-        lines.push(`流式输出：${this.streamEnabled ? "开" : "关"}`);
-        lines.push(`结束摘要：${this.summaryEnabled ? "开" : "关"}`);
-        lines.push(`发送者白名单：${this.config.allowUsers.length === 0 ? "全部放行" : `${this.config.allowUsers.length} 人`}`);
-        lines.push(`会话白名单：${this.config.allowChats.length === 0 ? "全部放行" : `${this.config.allowChats.length} 个`}`);
-        lines.push(`状态目录：${this.config.stateDir ?? ".dsh-connect"}`);
+        lines.push(this.t.chatCountField(binding?.sessions.length ?? 0));
+        lines.push(this.t.streamLabel(this.streamEnabled));
+        lines.push(this.t.summaryLabel(this.summaryEnabled));
+        lines.push(this.t.progressSetting(this.progressTimeoutMs === 0 ? this.t.progressOff : this.t.progressMinutes(Math.round(this.progressTimeoutMs / 60_000))));
+        lines.push(this.t.allowUsersField(this.config.allowUsers.length, this.config.allowUsers.length === 0));
+        lines.push(this.t.allowChatsField(this.config.allowChats.length, this.config.allowChats.length === 0));
+        lines.push(this.t.stateDirField(this.config.stateDir ?? ".dsh-connect"));
         await this.adapter.sendText(target, lines.join("\n"));
     }
     async modelMenuItems() {
@@ -683,7 +1542,7 @@ export class AgentRunner {
             },
         }));
         if (items.length === 0) {
-            items.push({ id: "model:none", label: "（未发现可用模型）", onSelect: async () => { } });
+            items.push({ id: "model:none", label: this.t.noModelsFound, onSelect: async () => { } });
         }
         return items;
     }
@@ -700,7 +1559,7 @@ export class AgentRunner {
                 // Skip providers whose catalog cannot be listed.
             }
             for (const m of models) {
-                out.push({ provider: p.id, model: m.id, name: `${m.name || m.id}（${p.name || p.id}）` });
+                out.push({ provider: p.id, model: m.id, name: this.t.modelName(m.name || m.id, p.name || p.id) });
             }
         }
         return out;
@@ -718,14 +1577,14 @@ export class AgentRunner {
     reasoningMenuItems() {
         const current = this.defaultSelection();
         const efforts = [
-            { id: "low", name: "低 (low)" },
-            { id: "medium", name: "中 (medium)" },
-            { id: "high", name: "高 (high)" },
+            { 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 ? "● " : ""}默认（跟随模型）`,
+                label: `${current.reasoningEffort === undefined ? "● " : ""}${this.t.effortDefault}`,
                 leaf: true,
                 onSelect: async (t, m) => {
                     await this.setReasoning(undefined, m);
@@ -754,84 +1613,198 @@ export class AgentRunner {
         });
         await this.newChat(msg);
     }
+    /** Switch the user-facing language for this chat, persisted in its binding. */
+    async setLanguage(lang, target, msg) {
+        if (lang === this.language)
+            return;
+        this.language = lang;
+        this.t = messages(lang);
+        // Persist into the chat's binding (create one if the chat has no session yet).
+        const binding = this.bindings.get(this.channel, this.chatKey);
+        if (binding !== undefined) {
+            this.bindings.put({ ...binding, language: lang, lastActiveAt: Date.now() });
+        }
+        else {
+            this.bindings.put({
+                channel: this.channel,
+                chatKey: this.chatKey,
+                chatType: this.chatType,
+                sessionId: "",
+                ownerKey: msg.senderKey,
+                createdAt: Date.now(),
+                lastActiveAt: Date.now(),
+                language: lang,
+                sessions: [],
+            });
+        }
+        await this.adapter.sendText(target, this.t.languageSet(lang === "zh" ? this.t.languageZh : this.t.languageEn));
+    }
+    /**
+     * Switch the notification level for this chat (persisted in its binding and
+     * effective immediately for the next streaming reply).
+     */
+    async setNotifyLevel(level, target, msg) {
+        this.notifyLevel = level;
+        const binding = this.bindings.get(this.channel, this.chatKey);
+        if (binding !== undefined) {
+            this.bindings.put({ ...binding, notifyLevel: level, lastActiveAt: Date.now() });
+        }
+        else {
+            this.bindings.put({
+                channel: this.channel,
+                chatKey: this.chatKey,
+                chatType: this.chatType,
+                sessionId: "",
+                ownerKey: msg.senderKey,
+                createdAt: Date.now(),
+                lastActiveAt: Date.now(),
+                notifyLevel: level,
+                sessions: [],
+            });
+        }
+        const label = level === "full" ? this.t.notifyFull : level === "important" ? this.t.notifyImportant : this.t.notifyResult;
+        const desc = level === "full" ? this.t.notifyFullDesc : level === "important" ? this.t.notifyImportantDesc : this.t.notifyResultDesc;
+        await this.adapter.sendText(target, this.t.notifySet(label, desc));
+    }
+    /** Show the three-level notification picker (used by the `/notify` command). */
+    async openNotifyPicker(target, msg) {
+        const options = [
+            { id: "notify:full", label: this.t.notifyFull },
+            { id: "notify:important", label: this.t.notifyImportant },
+            { id: "notify:result", label: this.t.notifyResult },
+        ];
+        const { choice } = await this.adapter.promptChoice(target, { title: this.t.menuNotify, options });
+        if (choice === undefined)
+            return;
+        const level = choice.startsWith("notify:") ? choice.slice("notify:".length) : undefined;
+        if (level !== "full" && level !== "important" && level !== "result")
+            return;
+        await this.setNotifyLevel(level, target, msg);
+    }
+    /**
+     * Switch the proactive progress-notice interval for this chat (persisted in
+     * its binding and effective for the next turn; 0 disables the watchdog).
+     */
+    async setProgressTimeout(ms, target, msg) {
+        this.progressTimeoutMs = ms;
+        const binding = this.bindings.get(this.channel, this.chatKey);
+        if (binding !== undefined) {
+            this.bindings.put({ ...binding, progressTimeoutMs: ms, lastActiveAt: Date.now() });
+        }
+        else {
+            this.bindings.put({
+                channel: this.channel,
+                chatKey: this.chatKey,
+                chatType: this.chatType,
+                sessionId: "",
+                ownerKey: msg.senderKey,
+                createdAt: Date.now(),
+                lastActiveAt: Date.now(),
+                progressTimeoutMs: ms,
+                sessions: [],
+            });
+        }
+        const label = ms === 0 ? this.t.progressOff : this.t.progressMinutes(Math.round(ms / 60_000));
+        await this.adapter.sendText(target, this.t.progressSet(label));
+    }
+    /** Show the progress-interval picker (used by the `/progress` command). */
+    async openProgressPicker(target, msg) {
+        const options = [
+            { id: "progress:0", label: this.t.progressOff },
+            { id: "progress:120000", label: this.t.progressMinutes(2) },
+            { id: "progress:300000", label: this.t.progressMinutes(5) },
+            { id: "progress:600000", label: this.t.progressMinutes(10) },
+            { id: "progress:900000", label: this.t.progressMinutes(15) },
+            { id: "progress:1800000", label: this.t.progressMinutes(30) },
+        ];
+        const { choice } = await this.adapter.promptChoice(target, { title: this.t.progressMenuTitle, options });
+        if (choice === undefined || !choice.startsWith("progress:"))
+            return;
+        const ms = Number(choice.slice("progress:".length));
+        if (!Number.isInteger(ms) || ms < 0)
+            return;
+        await this.setProgressTimeout(ms, target, msg);
+    }
     async showPlugins(target) {
         const loader = this.ctx.get("loader");
         const all = [...(loader?.entries?.() ?? [])];
         if (all.length === 0) {
-            await this.adapter.sendText(target, "未获取到插件清单。");
+            await this.adapter.sendText(target, this.t.noPlugins);
             return;
         }
         const shown = all.slice(0, 50);
         const lines = shown.map((e) => {
-            const status = e.disabled ? "⛔ 禁用" : "✅ 启用";
+            const status = e.disabled ? this.t.pluginDisabled : this.t.pluginEnabled;
             return `${status}  ${e.id}${e.options.name ? `  (${e.options.name})` : ""}`;
         });
         if (all.length > shown.length)
-            lines.push(`… 共 ${all.length} 个，仅显示前 ${shown.length} 个`);
-        await this.adapter.sendText(target, `插件（${all.length}）：\n${lines.join("\n")}`);
+            lines.push(this.t.pluginsTruncated(all.length, shown.length));
+        await this.adapter.sendText(target, this.t.pluginsCount(all.length) + lines.join("\n"));
     }
     async createWorkspace(path, target) {
         if (!isAbsolute(path)) {
-            await this.adapter.sendText(target, "请输入绝对路径，例如 `/workspace D:\\projects\\new-app`。");
+            await this.adapter.sendText(target, this.t.workspaceUsage);
             return;
         }
         try {
             if (!existsSync(path) || !statSync(path).isDirectory()) {
-                await this.adapter.sendText(target, `目录不存在或不是文件夹：${path}\n（请先创建该目录，再执行 /workspace）`);
+                await this.adapter.sendText(target, this.t.dirNotExistsHint(path));
                 return;
             }
         }
         catch {
-            await this.adapter.sendText(target, `无法访问目录：${path}`);
+            await this.adapter.sendText(target, this.t.dirUnreadable(path));
             return;
         }
         const registry = this.ctx.get("workspaceRegistry");
         if (registry?.create === undefined) {
-            await this.adapter.sendText(target, "工作区服务不可用。");
+            await this.adapter.sendText(target, this.t.workspaceServiceUnavailable);
             return;
         }
         try {
             const ws = await registry.create(path);
-            await this.adapter.sendText(target, `工作区已创建：\n${ws.title}  (${ws.path})`);
+            await this.adapter.sendText(target, this.t.workspaceCreated(ws.title, ws.path));
         }
         catch (error) {
-            await this.adapter.sendText(target, `创建失败：${error instanceof Error ? error.message : String(error)}`);
+            await this.adapter.sendText(target, this.t.createFailed(error instanceof Error ? error.message : String(error)));
         }
     }
     async compact(target) {
         const agent = this.agent;
         if (agent === undefined) {
-            await this.adapter.sendText(target, "当前没有活动会话，无法压缩。");
+            await this.adapter.sendText(target, this.t.noActiveSessionCompact);
             return;
         }
         if (agent.status !== "idle") {
-            await this.adapter.sendText(target, "当前会话正在运行，请稍后再试（或先 /stop）。");
+            await this.adapter.sendText(target, this.t.sessionRunning);
             return;
         }
         const presets = this.ctx.get("agentPresets");
         const compaction = presets?.serviceFor?.(agent, "compaction");
         if (compaction?.compactNow === undefined) {
-            await this.adapter.sendText(target, "压缩服务不可用（当前预设未挂载压缩后端）。");
+            await this.adapter.sendText(target, this.t.compactionUnavailable);
             return;
         }
         try {
+            // Compaction can take a while — tell the user it started, then report the outcome.
+            await this.adapter.sendText(target, this.t.compactStarted);
             const result = await compaction.compactNow(agent, new AbortController().signal);
             if (result === null) {
-                await this.adapter.sendText(target, "没有可压缩的历史。");
+                await this.adapter.sendText(target, this.t.nothingToCompact);
             }
             else {
-                await this.adapter.sendText(target, "上下文已压缩。");
+                await this.adapter.sendText(target, this.t.compactDone);
             }
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
-            await this.adapter.sendText(target, `压缩失败：${truncate(msg)}`);
+            await this.adapter.sendText(target, this.t.compactFailed(truncate(msg)));
         }
     }
     async showHistory(target, limit) {
         const agent = this.agent;
         if (agent === undefined) {
-            await this.adapter.sendText(target, "当前没有活动会话。");
+            await this.adapter.sendText(target, this.t.noActiveSession);
             return;
         }
         const events = agent.session.events;
@@ -850,51 +1823,414 @@ export class AgentRunner {
             }
         }
         if (rows.length === 0) {
-            await this.adapter.sendText(target, "会话里还没有消息。");
+            await this.adapter.sendText(target, this.t.noMessagesYet);
             return;
         }
-        await this.adapter.sendText(target, `最近 ${rows.length} 条消息：\n${rows.reverse().join("\n\n")}`);
+        await this.adapter.sendText(target, this.t.recentMessages(rows.length, rows.reverse().join("\n\n")));
     }
     async showGoals(target) {
         const agent = this.agent;
         if (agent === undefined) {
-            await this.adapter.sendText(target, "当前没有活动会话。");
+            await this.adapter.sendText(target, this.t.noActiveSession);
             return;
         }
         const goals = this.ctx.get("goals");
         const view = goals?.get?.(agent);
         if (view === undefined) {
-            await this.adapter.sendText(target, "当前没有进行中的目标。");
+            await this.adapter.sendText(target, this.t.noActiveGoals);
             return;
         }
-        const phaseLabels = {
-            active: "🟢 进行中",
-            paused: "⏸️ 已暂停",
-            blocked: "🚫 受阻",
-            complete: "✅ 已完成",
-        };
         const lines = [
-            `🎯 目标：${view.objective}`,
-            `状态：${phaseLabels[view.phase] ?? view.phase}`,
-            `轮次：${view.roundsStarted}/${view.maxGoalRounds}`,
-            `自动续跑：${view.activation === "armed" ? "已武装" : "已解除"}`,
+            this.t.goalObjective(view.objective),
+            this.t.goalStatus(this.goalPhaseLabel(view.phase)),
+            this.t.goalRounds(view.roundsStarted, view.maxGoalRounds),
+            this.t.goalAutoRun(view.activation === "armed"),
         ];
         if (view.blockedReason !== undefined)
-            lines.push(`受阻原因：${view.blockedReason.message}`);
+            lines.push(this.t.goalBlockedReason(view.blockedReason.message));
         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;
+        }
+    }
+    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;
+        }
+        const now = Date.now();
+        const locale = this.config.language === "en" ? "en-US" : "zh-CN";
+        const lines = reminders.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")));
+    }
     async showAllWorkspaces(target) {
         const registry = this.ctx.get("workspaceRegistry");
         const all = registry?.list?.() ?? [];
         if (all.length === 0) {
-            await this.adapter.sendText(target, "还没有工作区。可用 `/workspace <绝对路径>` 新建。");
+            await this.adapter.sendText(target, this.t.noWorkspaces);
             return;
         }
         const lines = all.map((w, i) => {
-            const sess = w.sessionIds !== undefined ? `  · ${w.sessionIds.length} 会话` : "";
+            const sess = w.sessionIds !== undefined ? this.t.workspaceSessions(w.sessionIds.length) : "";
             return `${i + 1}. ${w.title}${w.title !== w.path ? `  (${w.path})` : ""}${sess}`;
         });
-        await this.adapter.sendText(target, `工作区（${all.length}）：\n${lines.join("\n")}`);
+        await this.adapter.sendText(target, this.t.workspacesCount(all.length, lines.join("\n")));
+    }
+    /**
+     * Create or show Web mirror session for this chat.
+     * The mirror shares the same DSH session but enforces mutual exclusion:
+     * when Feishu is executing a task, Web is read-only, and vice versa.
+     */
+    async handleMirror(target, msg) {
+        const binding = this.bindings.get(this.channel, this.chatKey);
+        // Check timeout before showing status
+        this.checkAndReleaseTimeoutLock();
+        // Reload binding after potential timeout release
+        const updatedBinding = this.bindings.get(this.channel, this.chatKey);
+        // Check if mirror already exists
+        if (updatedBinding?.webMirrorSessionId !== undefined) {
+            const queuedCount = updatedBinding.queuedMessages?.length ?? 0;
+            const timeoutMin = updatedBinding.lockTimeoutMs ? Math.round(updatedBinding.lockTimeoutMs / 60000) : undefined;
+            await this.adapter.sendText(target, this.t.mirrorStatus(updatedBinding.webMirrorSessionId, updatedBinding.lockOwner, timeoutMin, queuedCount));
+            return;
+        }
+        // Create new mirror session (reuse current session)
+        const agent = this.agent;
+        if (agent === undefined) {
+            await this.adapter.sendText(target, this.t.mirrorNotConfigured);
+            return;
+        }
+        // The mirror uses the same session ID - it's a shared view
+        const mirrorSessionId = agent.id;
+        // Use custom timeout if provided, otherwise default to 5 minutes
+        const command = parseCommand(msg.text);
+        const customTimeoutMin = command.kind === "mirror" ? command.timeoutMin : undefined;
+        const defaultTimeoutMs = (customTimeoutMin ?? 5) * 60 * 1000;
+        // Update binding with mirror info and set initial lock to feishu
+        const newBinding = updatedBinding !== undefined
+            ? {
+                ...updatedBinding,
+                webMirrorSessionId: mirrorSessionId,
+                lockOwner: "feishu",
+                lockAcquiredAt: Date.now(),
+                lockTimeoutMs: defaultTimeoutMs,
+            }
+            : {
+                channel: this.channel,
+                chatKey: this.chatKey,
+                chatType: this.chatType,
+                sessionId: mirrorSessionId,
+                ownerKey: msg.senderKey,
+                createdAt: Date.now(),
+                lastActiveAt: Date.now(),
+                webMirrorSessionId: mirrorSessionId,
+                lockOwner: "feishu",
+                lockAcquiredAt: Date.now(),
+                lockTimeoutMs: defaultTimeoutMs,
+                sessions: [],
+            };
+        this.bindings.put(newBinding);
+        const timeoutMsg = customTimeoutMin !== undefined ? `（超时时间：${customTimeoutMin} 分钟）` : "";
+        await this.adapter.sendText(target, this.t.mirrorCreated(mirrorSessionId) + timeoutMsg);
+    }
+    /**
+     * Manually release session lock.
+     */
+    async handleUnlock(target) {
+        // Check timeout first
+        this.checkAndReleaseTimeoutLock();
+        const binding = this.bindings.get(this.channel, this.chatKey);
+        if (binding?.lockOwner === undefined) {
+            await this.adapter.sendText(target, this.t.unlockNoLock);
+            return;
+        }
+        // Process any queued messages before releasing
+        const queuedCount = binding.queuedMessages?.length ?? 0;
+        this.releaseLock();
+        let message = this.t.unlockSuccess;
+        if (queuedCount > 0) {
+            message += `\n${this.t.queueProcessed(queuedCount)}`;
+        }
+        await this.adapter.sendText(target, message);
+    }
+    /**
+     * Renew the current session lock timeout.
+     * Extends the lock by another full timeout period from now.
+     */
+    async handleRenewLock(target) {
+        const binding = this.bindings.get(this.channel, this.chatKey);
+        if (binding?.lockOwner === undefined) {
+            await this.adapter.sendText(target, this.t.unlockNoLock);
+            return;
+        }
+        const currentChannel = this.channel === "feishu" ? "feishu" : "web";
+        if (binding.lockOwner !== currentChannel) {
+            await this.adapter.sendText(target, this.t.sessionLockedBy(binding.lockOwner));
+            return;
+        }
+        // Renew the lock by resetting the acquisition time
+        const timeoutMs = binding.lockTimeoutMs ?? 5 * 60 * 1000;
+        this.bindings.put({
+            ...binding,
+            lockAcquiredAt: Date.now(),
+            lastActiveAt: Date.now()
+        });
+        const timeoutMin = Math.round(timeoutMs / 60000);
+        await this.adapter.sendText(target, this.t.lockRenewed(timeoutMin));
+    }
+    /**
+     * Export conversation history to Markdown or PDF.
+     */
+    async handleExport(target, format) {
+        const agent = this.agent;
+        if (agent === undefined) {
+            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`;
+            const filePath = join(this.workDir, fileName);
+            // Write to file
+            writeFileSync(filePath, markdown, "utf8");
+            await this.adapter.sendText(target, this.t.exportMarkdown(filePath));
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            await this.adapter.sendText(target, this.t.exportFailed(truncate(detail)));
+        }
+    }
+    /**
+     * Generate Markdown representation of the conversation history.
+     */
+    generateMarkdown(agent) {
+        const events = agent.session.events;
+        const lines = [];
+        // Header
+        lines.push(`# Conversation History`);
+        lines.push(``);
+        lines.push(`- **Session ID**: ${agent.id}`);
+        lines.push(`- **Exported At**: ${new Date().toISOString()}`);
+        lines.push(`- **Total Events**: ${events.length}`);
+        lines.push(``);
+        lines.push(`---`);
+        lines.push(``);
+        // Messages
+        for (const event of events) {
+            if (event.type === "user/message") {
+                const text = textOf(event.data);
+                if (text) {
+                    lines.push(`**👤 User**:`);
+                    lines.push(``);
+                    lines.push(text);
+                    lines.push(``);
+                }
+            }
+            else if (event.type === "assistant/message") {
+                const text = textOf(event.data.message);
+                if (text) {
+                    lines.push(`**🤖 Assistant**:`);
+                    lines.push(``);
+                    lines.push(text);
+                    lines.push(``);
+                }
+            }
+            else if (event.type === "turn/start") {
+                lines.push(`*Turn started at ${new Date().toLocaleTimeString()}*`);
+                lines.push(``);
+            }
+            else if (event.type === "turn/end") {
+                const reason = mapReason(event.data.reason.kind);
+                lines.push(`*Turn ended: ${this.reasonLabel(reason)}*`);
+                lines.push(``);
+                lines.push(`---`);
+                lines.push(``);
+            }
+        }
+        return lines.join("\n");
+    }
+    /**
+     * Check if the current channel has write access to the session.
+     * Returns true if allowed to send messages, false if read-only.
+     */
+    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);
+            return true;
+        }
+        return binding.lockOwner === channel;
+    }
+    /**
+     * 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);
+        if (binding === undefined)
+            return true;
+        // Check timeout before acquiring
+        if (this.isLockTimedOut(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;
+        }
+        // Locked by other channel - queue the message if from Web
+        return false;
+    }
+    /**
+     * Queue a message for later execution when lock is released.
+     * Returns the position in queue.
+     */
+    queueMessage(msg) {
+        const binding = this.bindings.get(this.channel, this.chatKey);
+        if (binding === undefined)
+            return -1;
+        const queued = binding.queuedMessages ?? [];
+        queued.push({
+            text: msg.text,
+            senderKey: msg.senderKey,
+            timestamp: Date.now(),
+            replyRef: msg.replyRef,
+            images: msg.images,
+            files: msg.files,
+        });
+        this.bindings.put({ ...binding, queuedMessages: queued });
+        return queued.length;
+    }
+    /**
+     * Process all queued messages after lock release.
+     * Re-enqueues them into the runner's message queue for actual execution.
+     */
+    async processQueuedMessages() {
+        const binding = this.bindings.get(this.channel, this.chatKey);
+        if (binding === undefined || !binding.queuedMessages || binding.queuedMessages.length === 0) {
+            return;
+        }
+        const messages = [...binding.queuedMessages];
+        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
+                this.queue.push(inboundMsg);
+            }
+            // Trigger processing if not already running
+            void this.drain();
+        }
+    }
+    /** Release session lock. */
+    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;
+    }
+    /** Check and release timed-out locks. */
+    checkAndReleaseTimeoutLock() {
+        const binding = this.bindings.get(this.channel, this.chatKey);
+        if (binding && this.isLockTimedOut(binding)) {
+            this.releaseTimeoutLock(binding);
+        }
+    }
+    /** Release a timed-out lock and notify. */
+    releaseTimeoutLock(binding) {
+        const timeoutMin = Math.round((binding.lockTimeoutMs ?? 5 * 60 * 1000) / 60000);
+        const lockedBy = binding.lockOwner;
+        this.bindings.put({
+            ...binding,
+            lockOwner: undefined,
+            lockAcquiredAt: undefined
+        });
+        // Notify users about timeout release
+        const adapter = this.adapters?.get(this.channel);
+        if (adapter && lockedBy) {
+            void adapter.sendText({ chatKey: this.chatKey, chatType: this.chatType }, this.t.lockTimeoutReleased(timeoutMin)).catch(() => undefined);
+        }
     }
 }
 //# sourceMappingURL=runner.js.map