dsh-connect 0.1.0 → 0.5.0

package/lib/runner.js

@@ -5,32 +5,27 @@
  * @module dsh-connect/runner
  */
 import { randomUUID } from "node:crypto";
-import { existsSync, statSync } from "node:fs";
-import { isAbsolute } from "node:path";
+import { existsSync, mkdirSync, statSync } 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,
     };
 }
-const REASON_LABELS = {
-    completed: "✅ 完成",
-    aborted: "⏹️ 已中止",
-    blocked: "🚫 阻塞",
-    error: "❌ 出错",
-    "max-tokens": "⚠️ 达到输出上限",
-    interrupted: "⚠️ 被中断",
-    unknown: "❓ 未知",
-};
 function mapReason(kind) {
     switch (kind) {
         case "completed":
@@ -80,15 +75,64 @@ export function summarizeTurn(events, firstSeq) {
 function truncate(text, max = 500) {
     return text.length <= max ? text : `${text.slice(0, max)}…`;
 }
-const MENU_TITLES = {
-    root: "主菜单",
-    workspace: "切换工作目录",
-    chat: "切换对话",
-    settings: "设置",
-    model: "切换模型",
-    reasoning: "推理强度",
-    notify: "通知设置",
-};
+function textOf(message) {
+    if (message === undefined)
+        return "";
+    return message.content
+        .filter((b) => b.type === "text" && typeof b.text === "string")
+        .map((b) => b.text ?? "")
+        .join("");
+}
+/** Lightweight fold of `schedule/change` events (create / delete / dispatch). */
+function foldReminders(events) {
+    const active = new Map();
+    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";
+}
 export class AgentRunner {
     ctx;
     config;
@@ -105,6 +149,7 @@ export class AgentRunner {
     workDir;
     streamEnabled = true;
     summaryEnabled = true;
+    t;
     constructor(ctx, config, channel, chatKey, chatType, adapter, bindings) {
         this.ctx = ctx;
         this.config = config;
@@ -114,6 +159,51 @@ export class AgentRunner {
         this.adapter = adapter;
         this.bindings = bindings;
         this.workDir = config.workDir ?? this.resolveDefaultWorkDir();
+        this.t = messages(config.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;
+        }
+    }
+    rootMenuSections() {
+        return [
+            { title: this.t.rootSectionWorkspace, ids: ["workspace"] },
+            { title: this.t.rootSectionChat, ids: ["chat", "history"] },
+            { title: this.t.rootSectionTask, ids: ["task", "goals", "schedule"] },
+            { title: this.t.rootSectionSystem, ids: ["status", "plugins", "compact", "settings"] },
+        ];
+    }
+    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() {
@@ -147,7 +237,7 @@ export class AgentRunner {
             }
             else if (chunk.type === "reasoning-delta" && !turn.reasoning) {
                 turn.reasoning = true;
-                turn.chunks.push("🤔 深度思考中…\n");
+                turn.chunks.push(this.t.thinkingHint);
             }
         }
     }
@@ -186,7 +276,7 @@ export class AgentRunner {
         catch (error) {
             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);
         }
     }
@@ -270,11 +360,12 @@ export class AgentRunner {
     }
     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);
@@ -286,10 +377,7 @@ export class AgentRunner {
         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" },
-        }));
+        agent.followup(await userMessage());
         await agent.whenIdle();
         await this.sessions.flush(agent.session);
         chunks.end();
@@ -299,6 +387,187 @@ export class AgentRunner {
         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 });
+        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;
+    }
+    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)
@@ -318,13 +587,13 @@ 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);
     }
@@ -333,17 +602,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": {
@@ -361,22 +630,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": {
@@ -391,8 +660,44 @@ export class AgentRunner {
                 await this.openMenu(target, msg, "settings", ["root"]);
                 break;
             }
+            case "plugins": {
+                await this.showPlugins(target);
+                break;
+            }
+            case "workspace": {
+                if (command.path === undefined) {
+                    await this.adapter.sendText(target, this.t.workspaceUsage);
+                    break;
+                }
+                await this.createWorkspace(command.path, target);
+                break;
+            }
+            case "compact": {
+                await this.compact(target);
+                break;
+            }
+            case "history": {
+                await this.showHistory(target, command.limit ?? 10);
+                break;
+            }
+            case "goals": {
+                await this.showGoals(target);
+                break;
+            }
+            case "schedule": {
+                await this.showSchedule(target);
+                break;
+            }
+            case "model": {
+                await this.openMenu(target, msg, "model", ["root"]);
+                break;
+            }
+            case "workspaces": {
+                await this.showAllWorkspaces(target);
+                break;
+            }
             case "help": {
-                await this.adapter.sendText(target, HELP_TEXT);
+                await this.adapter.sendText(target, helpText(this.t));
                 break;
             }
             default:
@@ -466,50 +771,68 @@ 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)
             add(p, p);
         return out;
     }
-    async openMenu(target, msg, menuId, stack = []) {
+    async openMenu(target, msg, menuId, stack = [], cardId) {
         const items = await this.menuItems(menuId);
         const options = items.map((i) => ({ id: i.id, label: i.label }));
+        options.push({ id: "menu:exit", label: this.t.menuExit });
         if (stack.length > 0)
-            options.push({ id: "menu:back", label: "🔙 返回" });
-        const choice = await this.adapter.promptChoice(target, { title: MENU_TITLES[menuId], options });
+            options.push({ id: "menu:back", label: this.t.menuBack });
+        const { choice, messageId } = await this.adapter.promptChoice(target, {
+            title: this.menuTitle(menuId),
+            options,
+            ...(menuId === "root" ? { sections: this.rootMenuSections(), footer: this.t.rootMenuFooter } : {}),
+        }, cardId);
         if (choice === undefined)
             return;
+        if (choice === "menu:exit") {
+            await this.adapter.closeMenu(messageId, this.t.menuClosed);
+            return;
+        }
         if (choice === "menu:back") {
             const parent = stack[stack.length - 1];
-            await this.openMenu(target, msg, parent, stack.slice(0, -1));
+            await this.openMenu(target, msg, parent, stack.slice(0, -1), messageId);
             return;
         }
         const item = items.find((i) => i.id === choice);
         if (item === undefined)
             return;
-        await item.onSelect(target, msg);
+        await item.onSelect(target, msg, messageId);
+        if (item.leaf === true) {
+            // Return to the root menu on the same card so the user can keep operating.
+            await this.openMenu(target, msg, "root", [], messageId);
+        }
     }
     async menuItems(menuId) {
         switch (menuId) {
             case "root":
                 return [
-                    { id: "workspace", label: "📁 切换工作目录", onSelect: (t, m) => this.openMenu(t, m, "workspace", ["root"]) },
-                    { id: "chat", label: "💬 切换对话", onSelect: (t, m) => this.openMenu(t, m, "chat", ["root"]) },
-                    { id: "status", label: "📊 查看状态", onSelect: (t) => this.showStatus(t) },
-                    { id: "task", label: "📋 查看任务", onSelect: (t) => this.showTasks(t) },
-                    { id: "settings", label: "⚙️ 设置", onSelect: (t, m) => this.openMenu(t, m, "settings", ["root"]) },
+                    { id: "workspace", label: this.t.menuWorkspaceAction, onSelect: (t, m, cardId) => this.openMenu(t, m, "workspace", ["root"], cardId) },
+                    { id: "chat", label: this.t.menuChatAction, onSelect: (t, m, cardId) => this.openMenu(t, m, "chat", ["root"], cardId) },
+                    { id: "status", label: this.t.menuStatusAction, leaf: true, onSelect: async (t) => { await this.showStatus(t); } },
+                    { id: "task", label: this.t.menuTaskAction, leaf: true, onSelect: async (t) => { await this.showTasks(t); } },
+                    { id: "history", label: this.t.menuHistoryAction, leaf: true, onSelect: async (t) => { await this.showHistory(t, 10); } },
+                    { id: "goals", label: this.t.menuGoalsAction, leaf: true, onSelect: async (t) => { await this.showGoals(t); } },
+                    { id: "schedule", label: this.t.menuScheduleAction, leaf: true, onSelect: async (t) => { await this.showSchedule(t); } },
+                    { id: "compact", label: this.t.menuCompactAction, leaf: true, onSelect: async (t) => { await this.compact(t); } },
+                    { id: "plugins", label: this.t.menuPluginsAction, leaf: true, onSelect: async (t) => { await this.showPlugins(t); } },
+                    { id: "settings", label: this.t.menuSettingsAction, onSelect: (t, m, cardId) => this.openMenu(t, m, "settings", ["root"], cardId) },
                 ];
             case "workspace": {
                 const workspaces = this.listWorkspaces();
                 return workspaces.map((w) => ({
                     id: `dir:${w.path}`,
                     label: `${w.path === this.workDir ? "● " : ""}${w.title}${w.title !== w.path ? `  (${w.path})` : ""}`,
+                    leaf: true,
                     onSelect: async (t, m) => {
                         this.workDir = w.path;
                         await this.newChat(m);
-                        await this.adapter.sendText(t, `工作目录已切换为：\n${w.path}`);
                     },
                 }));
             }
@@ -520,27 +843,27 @@ export class AgentRunner {
                 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);
-                        await this.adapter.sendText(t, `已切换到对话：${s.title || s.sessionId}`);
                     },
                 }));
                 items.push({
                     id: "action:new",
-                    label: "➕ 新建对话",
+                    label: this.t.menuNewChat,
+                    leaf: true,
                     onSelect: async (t, m) => {
                         await this.newChat(m);
-                        await this.adapter.sendText(t, "已开启新对话。");
                     },
                 });
                 return items;
             }
             case "settings":
                 return [
-                    { id: "model", label: "🤖 切换模型", onSelect: (t, m) => this.openMenu(t, m, "model", ["settings", "root"]) },
-                    { id: "reasoning", label: "🧠 推理强度", onSelect: (t, m) => this.openMenu(t, m, "reasoning", ["settings", "root"]) },
-                    { id: "notify", label: "🔔 通知设置", onSelect: (t, m) => this.openMenu(t, m, "notify", ["settings", "root"]) },
-                    { id: "overview", label: "📄 配置总览", onSelect: (t) => 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: "overview", label: this.t.menuSettingsOverview, leaf: true, onSelect: async (t) => { await this.showSettings(t); } },
                 ];
             case "model":
                 return await this.modelMenuItems();
@@ -550,18 +873,18 @@ export class AgentRunner {
                 return [
                     {
                         id: "stream",
-                        label: `流式输出：${this.streamEnabled ? "开" : "关"}`,
-                        onSelect: async (t) => {
+                        label: this.t.streamLabel(this.streamEnabled),
+                        leaf: true,
+                        onSelect: async () => {
                             this.streamEnabled = !this.streamEnabled;
-                            await this.adapter.sendText(t, `流式输出已${this.streamEnabled ? "开启" : "关闭"}。`);
                         },
                     },
                     {
                         id: "summary",
-                        label: `结束摘要：${this.summaryEnabled ? "开" : "关"}`,
-                        onSelect: async (t) => {
+                        label: this.t.summaryLabel(this.summaryEnabled),
+                        leaf: true,
+                        onSelect: async () => {
                             this.summaryEnabled = !this.summaryEnabled;
-                            await this.adapter.sendText(t, `结束摘要已${this.summaryEnabled ? "开启" : "关闭"}。`);
                         },
                     },
                 ];
@@ -570,30 +893,40 @@ export class AgentRunner {
     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" ? "🟢 运行中" : "⚪ 空闲";
+        const label = agent.status === "running" ? this.t.statusRunning : 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(label),
+            this.t.modelField(model),
+            this.t.workdirField(this.workDir),
+            this.t.queuedField(this.queue.length),
+            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"));
     }
     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);
@@ -601,21 +934,21 @@ 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.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() {
@@ -624,13 +957,13 @@ export class AgentRunner {
         const items = choices.map((c) => ({
             id: `model:${c.provider}:${c.model}`,
             label: `${c.provider === current.provider && c.model === current.model ? "● " : ""}${c.name}`,
+            leaf: true,
             onSelect: async (t, m) => {
                 await this.setModel(c.provider, c.model, m);
-                await this.adapter.sendText(t, `模型已切换为：${c.name}`);
             },
         }));
         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;
     }
@@ -647,7 +980,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;
@@ -665,17 +998,17 @@ 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);
-                    await this.adapter.sendText(t, "推理强度已设为默认。");
                 },
             },
         ];
@@ -683,9 +1016,9 @@ export class AgentRunner {
             items.push({
                 id: `effort:${e.id}`,
                 label: `${e.id === current.reasoningEffort ? "● " : ""}${e.name}`,
+                leaf: true,
                 onSelect: async (t, m) => {
                     await this.setReasoning(e.id, m);
-                    await this.adapter.sendText(t, `推理强度已切换为：${e.name}`);
                 },
             });
         }
@@ -701,5 +1034,177 @@ export class AgentRunner {
         });
         await this.newChat(msg);
     }
+    async showPlugins(target) {
+        const loader = this.ctx.get("loader");
+        const all = [...(loader?.entries?.() ?? [])];
+        if (all.length === 0) {
+            await this.adapter.sendText(target, this.t.noPlugins);
+            return;
+        }
+        const shown = all.slice(0, 50);
+        const lines = shown.map((e) => {
+            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(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, this.t.workspaceUsage);
+            return;
+        }
+        try {
+            if (!existsSync(path) || !statSync(path).isDirectory()) {
+                await this.adapter.sendText(target, this.t.dirNotExistsHint(path));
+                return;
+            }
+        }
+        catch {
+            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, this.t.workspaceServiceUnavailable);
+            return;
+        }
+        try {
+            const ws = await registry.create(path);
+            await this.adapter.sendText(target, this.t.workspaceCreated(ws.title, ws.path));
+        }
+        catch (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, this.t.noActiveSessionCompact);
+            return;
+        }
+        if (agent.status !== "idle") {
+            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, this.t.compactionUnavailable);
+            return;
+        }
+        try {
+            const result = await compaction.compactNow(agent, new AbortController().signal);
+            if (result === null) {
+                await this.adapter.sendText(target, this.t.nothingToCompact);
+            }
+            else {
+                await this.adapter.sendText(target, this.t.contextCompacted);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            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, this.t.noActiveSession);
+            return;
+        }
+        const events = agent.session.events;
+        const rows = [];
+        for (let i = events.length - 1; i >= 0 && rows.length < limit; i--) {
+            const e = events[i];
+            if (e.type === "user/message") {
+                const text = textOf(e.data);
+                if (text !== "")
+                    rows.push(`👤 ${truncate(text, 100)}`);
+            }
+            else if (e.type === "assistant/message") {
+                const text = textOf(e.data.message);
+                if (text !== "")
+                    rows.push(`🤖 ${truncate(text, 100)}`);
+            }
+        }
+        if (rows.length === 0) {
+            await this.adapter.sendText(target, this.t.noMessagesYet);
+            return;
+        }
+        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, this.t.noActiveSession);
+            return;
+        }
+        const goals = this.ctx.get("goals");
+        const view = goals?.get?.(agent);
+        if (view === undefined) {
+            await this.adapter.sendText(target, this.t.noActiveGoals);
+            return;
+        }
+        const lines = [
+            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(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, this.t.noWorkspaces);
+            return;
+        }
+        const lines = all.map((w, i) => {
+            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, this.t.workspacesCount(all.length, lines.join("\n")));
+    }
 }
 //# sourceMappingURL=runner.js.map