dsh-connect 0.7.0 → 0.7.1

package/lib/runner.js

@@ -10,8 +10,10 @@ import { copyFile, readFile } from "node:fs/promises";
 import { basename, isAbsolute, join } from "node:path";
 import { SessionId } from "@deepseek-ai/dsh-session";
 import { createUserMessage, ReasoningEffortId } from "@deepseek-ai/dsh-llm";
-import { createAsyncQueue } from "./stream.js";
+import { createAsyncQueue, applyStreamChunk, applyToolCall, toolCallSummary, questionTextOf, summarizeTurn, classifyError, mapReason, truncate, fmtTokens, textOf, } from "./stream.js";
 import { helpText, parseCommand } from "./commands.js";
+import { menuTitle, rootMenuSections, reasonLabel, goalPhaseLabel, listWorkspaces } from "./menus.js";
+import { MenuController } from "./menu-controller.js";
 import { messages } from "./i18n.js";
 import { DEFAULT_LOCK_TIMEOUT_MS, acquire as lockAcquire, canWrite as lockCanWrite, isLockTimedOut as lockIsTimedOut, release as lockRelease, } from "./mirror-lock.js";
 import { formatRemindAt, parseRemindTime } from "./scheduler.js";
@@ -27,280 +29,10 @@ export function resolveConnectConfig(config) {
         stateDir: config.stateDir,
         autoMirror: config.autoMirror ?? true, // Enabled by default
         streamHeartbeatMs: config.streamHeartbeatMs ?? 60_000,
-        notifyLevel: config.notifyLevel ?? "important",
+        notifyLevel: config.notifyLevel ?? "result",
         progressTimeoutMs: config.progressTimeoutMs ?? 5 * 60_000, // Proactive progress notice after 5 min of silence
     };
 }
-/**
- * Assemble one `assistant/chunk` event into the streaming queue with visible
- * structure. DSH streams one block per LLM content block and block boundaries
- * carry no newline of their own, so without separators every block (and the
- * reasoning phase vs the final answer) would be glued together in the chat
- * card. This inserts a blank line between blocks and before the answer, keeps
- * the thinking hint once per turn, expands reasoning soft breaks (Feishu's
- * streaming card collapses single `\n`), and falls back to whole-block text
- * for blocks that arrived only via `block-end`. Every push refreshes
- * `lastPushAt` so the liveness heartbeat knows the card is still moving.
- * @param state - the turn's mutable assembly state.
- * @param thinkingHint - localized hint text pushed at the first reasoning delta.
- * @param chunk - the assistant chunk event's `chunk` payload.
- */
-/** Every line-break run becomes a paragraph break (Feishu's streaming card collapses single `\n`). */
-function expandLineBreaks(text) {
-    return text.replace(/\r\n?/g, "\n").replace(/\n+/g, "\n\n");
-}
-export function applyStreamChunk(state, thinkingHint, chunk, level = "full") {
-    if (chunk.type === "text-delta" || chunk.type === "reasoning-delta") {
-        const isReasoning = chunk.type === "reasoning-delta";
-        // Reasoning content is only streamed in `full` mode; `important` shows
-        // just the thinking hint and `result` shows nothing until the answer.
-        if (isReasoning && level !== "full") {
-            if (level === "important" && !state.hintPushed) {
-                state.hintPushed = true;
-                state.chunks.push(thinkingHint);
-                state.pushedAny = true;
-                state.lastPushAt = Date.now();
-            }
-            return;
-        }
-        if (state.pushedAny) {
-            const newBlock = chunk.index !== undefined && state.lastIndex !== undefined && chunk.index !== state.lastIndex;
-            const reasoningToAnswer = !isReasoning && state.reasoning;
-            if (newBlock || reasoningToAnswer)
-                state.chunks.push("\n\n");
-        }
-        if (isReasoning) {
-            if (!state.hintPushed) {
-                state.hintPushed = true;
-                state.chunks.push(thinkingHint);
-            }
-            const text = chunk.text ?? "";
-            if (text !== "") {
-                state.chunks.push(expandLineBreaks(text));
-            }
-            state.reasoning = true;
-        }
-        else {
-            const text = chunk.text ?? "";
-            state.chunks.push(text);
-            state.lastText += text;
-            state.reasoning = false;
-        }
-        state.lastIndex = chunk.index;
-        state.pushedAny = true;
-        state.lastPushAt = Date.now();
-        return;
-    }
-    if (chunk.type === "block-end") {
-        // Short blocks may arrive whole here with no preceding delta chunks.
-        // Fall back to the block text when this index never streamed deltas, so
-        // no content is silently dropped (guarded by index against duplication;
-        // each step restarts block indices, and a tool call resets `lastIndex`,
-        // so a same-index block-end after streamed deltas is reliably detected).
-        const index = chunk.index;
-        const blockType = chunk.block?.type;
-        const text = chunk.block?.text;
-        if (blockType === "reasoning" && level !== "full") {
-            // Reasoning block text is never streamed outside `full` mode.
-            if (level === "important" && !state.hintPushed) {
-                state.hintPushed = true;
-                state.chunks.push(thinkingHint);
-                state.pushedAny = true;
-                state.lastPushAt = Date.now();
-            }
-            return;
-        }
-        if (typeof text === "string" && text.length > 0 && (index === undefined || index !== state.lastIndex)) {
-            if (state.pushedAny)
-                state.chunks.push("\n\n");
-            if (blockType === "reasoning" && !state.hintPushed) {
-                state.hintPushed = true;
-                state.chunks.push(thinkingHint);
-            }
-            state.chunks.push(blockType === "reasoning" ? expandLineBreaks(text) : text);
-            if (blockType !== "reasoning")
-                state.lastText += text;
-            state.lastIndex = index;
-            state.pushedAny = true;
-            state.reasoning = blockType === "reasoning";
-            state.lastPushAt = Date.now();
-        }
-    }
-}
-/**
- * Push a localized tool-call status line into the streaming queue so long
- * tool-execution stretches stay visibly alive (the Web GUI shows tool calls;
- * the chat card should too). Ends the reasoning phase and drops the block
- * index so the next content block gets its own separator instead of stacking
- * one on top of the tool line's own blank lines.
- * @param state - the turn's mutable assembly state.
- * @param label - the localized status line, e.g. "🔧 调用工具 `pwsh` — …".
- */
-export function applyToolCall(state, label) {
-    state.chunks.push(`\n\n${label}\n\n`);
-    state.reasoning = false;
-    state.lastIndex = undefined;
-    state.pushedAny = true;
-    state.lastPushAt = Date.now();
-}
-/** Pull a short human summary out of a tool call's `arguments` JSON (whitespace folded to one line). */
-export function toolCallSummary(argumentsJson) {
-    if (typeof argumentsJson !== "string")
-        return undefined;
-    const fold = (value) => value.replace(/\s+/g, " ").trim();
-    try {
-        const parsed = JSON.parse(argumentsJson);
-        const description = parsed?.description;
-        if (typeof description === "string" && description !== "") {
-            const folded = fold(description);
-            return folded.length > 60 ? `${folded.slice(0, 60)}…` : folded;
-        }
-        for (const key of ["file_path", "path"]) {
-            const value = parsed?.[key];
-            if (typeof value === "string" && value !== "") {
-                const folded = fold(value);
-                return folded.length > 60 ? `${folded.slice(0, 60)}…` : folded;
-            }
-        }
-    }
-    catch {
-        // Not JSON — no summary.
-    }
-    return undefined;
-}
-/** Pull the first question's text out of an `ask_user_question` arguments JSON (whitespace folded to one line). */
-export function questionTextOf(argumentsJson) {
-    if (typeof argumentsJson !== "string")
-        return "";
-    try {
-        const parsed = JSON.parse(argumentsJson);
-        const first = Array.isArray(parsed?.questions) ? parsed.questions[0] : undefined;
-        const text = typeof first?.question === "string" ? first.question : "";
-        const folded = text.replace(/\s+/g, " ").trim();
-        return folded.length > 60 ? `${folded.slice(0, 60)}…` : folded;
-    }
-    catch {
-        // Not JSON — no question text.
-    }
-    return "";
-}
-function mapReason(kind) {
-    switch (kind) {
-        case "completed":
-        case "aborted":
-        case "blocked":
-        case "error":
-        case "max-tokens":
-        case "interrupted":
-            return kind;
-        default:
-            return "unknown";
-    }
-}
-export function summarizeTurn(events, firstSeq) {
-    let started = false;
-    let text = "";
-    let reason = "unknown";
-    let code;
-    let message;
-    let model;
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let cacheReadTokens = 0;
-    let contextSize;
-    let contextWindow;
-    let steps = 0;
-    let turnStartTime;
-    let turnEndTime;
-    for (const event of events) {
-        if (event.seq < firstSeq)
-            continue;
-        if (event.type === "turn/start") {
-            started = true;
-            turnStartTime = typeof event.time === "number" ? event.time : undefined;
-            continue;
-        }
-        if (!started)
-            continue;
-        if (event.type === "step/start")
-            steps += 1;
-        if (event.type === "request/context") {
-            const provider = typeof event.data.provider === "string" ? event.data.provider : undefined;
-            const m = typeof event.data.model === "string" ? event.data.model : undefined;
-            if (provider !== undefined && m !== undefined)
-                model = `${provider}/${m}`;
-            if (typeof event.data.contextWindow === "number")
-                contextWindow = event.data.contextWindow;
-        }
-        if (event.type === "assistant/message") {
-            const usage = event.data.usage;
-            if (usage !== undefined) {
-                inputTokens += typeof usage.inputTokens === "number" ? usage.inputTokens : 0;
-                outputTokens += typeof usage.outputTokens === "number" ? usage.outputTokens : 0;
-                cacheReadTokens += typeof usage.cacheReadTokens === "number" ? usage.cacheReadTokens : 0;
-                if (typeof usage.inputTokens === "number")
-                    contextSize = usage.inputTokens;
-            }
-            const joined = event.data.message.content
-                .filter((block) => block.type === "text")
-                .map((block) => block.text)
-                .join("");
-            if (joined !== "")
-                text = joined;
-        }
-        if (event.type === "turn/end") {
-            turnEndTime = typeof event.time === "number" ? event.time : undefined;
-            reason = mapReason(event.data.reason.kind);
-            if (event.data.reason.kind === "error") {
-                code = event.data.reason.error.code;
-                message = event.data.reason.error.message;
-            }
-        }
-    }
-    const elapsedMs = turnStartTime !== undefined && turnEndTime !== undefined && turnEndTime >= turnStartTime
-        ? turnEndTime - turnStartTime
-        : undefined;
-    return {
-        reason,
-        text,
-        ...(code === undefined ? {} : { code }),
-        ...(message === undefined ? {} : { message }),
-        ...(model === undefined ? {} : { model }),
-        ...(inputTokens > 0 ? { inputTokens } : {}),
-        ...(outputTokens > 0 ? { outputTokens } : {}),
-        ...(cacheReadTokens > 0 ? { cacheReadTokens } : {}),
-        ...(contextSize === undefined ? {} : { contextSize }),
-        ...(contextWindow === undefined ? {} : { contextWindow }),
-        ...(steps > 0 ? { steps } : {}),
-        ...(elapsedMs === undefined ? {} : { elapsedMs }),
-    };
-}
-function truncate(text, max = 500) {
-    return text.length <= max ? text : `${text.slice(0, max)}…`;
-}
-/** Classify an error message into an advice bucket (keyword-based, best-effort). */
-export function classifyError(detail) {
-    const d = detail.toLowerCase();
-    if (/(permission|forbidden|denied|not have access|no access|unauthorized|403|sandbox|acl |isn't permitted|not permitted|access denied)/.test(d))
-        return "permission";
-    if (/(timeout|econnrefused|econnreset|enotfound|enetunreach|etimedout|socket|network|proxy|tls|certificate|fetch failed|connect |unreachable|dns)/.test(d))
-        return "network";
-    if (/(model|quota|rate ?limit|429|insufficient|balance|token(s)? (limit|length)|max_tokens|context length|credit)/.test(d))
-        return "model";
-    return "generic";
-}
-/** Thousands-separated token count for display. */
-function fmtTokens(n) {
-    return n.toLocaleString("en-US");
-}
-function textOf(message) {
-    if (message === undefined)
-        return "";
-    return message.content
-        .filter((b) => b.type === "text" && typeof b.text === "string")
-        .map((b) => b.text ?? "")
-        .join("");
-}
 /** Lightweight fold of `schedule/change` events (create / delete / dispatch). */
 function foldReminders(events) {
     const active = new Map();
@@ -378,6 +110,7 @@ export class AgentRunner {
     notifyLevel;
     progressTimeoutMs;
     t;
+    menu;
     constructor(ctx, config, channel, chatKey, chatType, adapter, bindings, adapters, 
     /**
      * Route a replayed queued message back into the runner of its own channel
@@ -404,54 +137,16 @@ export class AgentRunner {
         this.notifyLevel = stored?.notifyLevel ?? config.notifyLevel;
         this.progressTimeoutMs = stored?.progressTimeoutMs ?? config.progressTimeoutMs;
         this.t = messages(this.language);
+        this.menu = new MenuController(this);
     }
     menuTitle(menuId) {
-        switch (menuId) {
-            case "root":
-                return this.t.menuRoot;
-            case "workspace":
-                return this.t.menuWorkspace;
-            case "chat":
-                return this.t.menuChat;
-            case "settings":
-                return this.t.menuSettings;
-            case "model":
-                return this.t.menuModel;
-            case "reasoning":
-                return this.t.menuReasoning;
-            case "notify":
-                return this.t.menuNotify;
-            case "language":
-                return this.t.menuSettingsLanguage;
-            case "progress":
-                return this.t.progressMenuTitle;
-        }
+        return menuTitle(menuId, this.t);
     }
     rootMenuSections() {
-        return [
-            { title: this.t.rootSectionWorkspace, ids: ["workspace"], columnsPerRow: 1 },
-            { title: this.t.rootSectionChat, ids: ["chat", "history"], columnsPerRow: 1 },
-            { title: this.t.rootSectionTask, ids: ["task", "goals", "schedule"], columnsPerRow: 2 },
-            { title: this.t.rootSectionSystem, ids: ["status", "plugins", "compact", "settings"], columnsPerRow: 2 },
-        ];
+        return rootMenuSections(this.t);
     }
     reasonLabel(reason) {
-        switch (reason) {
-            case "completed":
-                return this.t.reasonCompleted;
-            case "aborted":
-                return this.t.reasonAborted;
-            case "blocked":
-                return this.t.reasonBlocked;
-            case "error":
-                return this.t.reasonError;
-            case "max-tokens":
-                return this.t.reasonMaxTokens;
-            case "interrupted":
-                return this.t.reasonInterrupted;
-            default:
-                return this.t.reasonUnknown;
-        }
+        return reasonLabel(reason, this.t);
     }
     /** Prefer the user's first DSH workspace over the process cwd as default. */
     resolveDefaultWorkDir() {
@@ -528,16 +223,18 @@ export class AgentRunner {
             else {
                 turn.milestone = this.t.toolCalling(name, undefined);
             }
-            // `result` mode shows nothing until the final answer; `important` shows
-            // the tool name with a step counter, `full` also carries the summary.
-            if (this.notifyLevel === "result")
+            // `result` mode shows nothing until the final answer.
+            if (this.notifyLevel === 'result')
                 return;
-            const base = name === "ask_user_question"
+            // Keep the streaming card short: push a status line only once per distinct
+            // tool (not once per call, which would log "tool #51" spam), and label it
+            // with the tool name rather than a running counter.
+            if (turn.lastToolName === name)
+                return;
+            turn.lastToolName = name;
+            const label = name === 'ask_user_question'
                 ? this.t.questionToolCall(questionTextOf(event.data.arguments))
-                : this.t.toolStepLabel(turn.toolCount, name);
-            const label = name === "ask_user_question" || this.notifyLevel !== "full" || summary === undefined
-                ? base
-                : `${base} — ${summary}`;
+                : this.t.toolCalling(name, this.notifyLevel === 'full' ? summary : undefined);
             applyToolCall(turn, label);
         }
     }
@@ -915,7 +612,7 @@ export class AgentRunner {
         this.turn = {
             firstSeq, chunks, lastText: "",
             reasoning: false, hintPushed: false, lastIndex: undefined, pushedAny: false,
-            startedAt: now, lastPushAt: now, toolCount: 0, contextNudged: false, compactAfterTurn: false,
+            startedAt: now, lastPushAt: now, toolCount: 0, lastToolName: undefined, contextNudged: false, compactAfterTurn: false,
         };
         // Liveness heartbeat: while the agent is working, keep the streaming card
         // visibly alive even through long reasoning or tool-execution stretches
@@ -936,26 +633,29 @@ export class AgentRunner {
             }, heartbeatMs)
             : undefined;
         // Proactive progress watchdog: when no standalone card/text has been sent
-        // for `progressTimeoutMs` (default 5 min, user-configurable), send a status
-        // card reporting the latest milestone so a long turn never looks frozen.
-        // Streaming-card heartbeats deliberately do NOT reset this — the user asked
-        // for an explicit, separate nudge.
+        // for `progressTimeoutMs` (default 5 min, user-configurable), re-sync the
+        // latest milestone INTO the streaming card (via its chunk stream) so a long
+        // turn never looks frozen — WITHOUT posting a separate message. The card is
+        // edited in place, keeping the chat history clean. Streaming-card heartbeats
+        // deliberately do NOT reset this: the progress watchdog only fires when no
+        // explicit milestone sync has been pushed for the configured interval.
         const progressTimeoutMs = this.progressTimeoutMs;
-        let lastStandaloneNoticeAt = now;
+        let lastProgressNoticeAt = now;
         const progressWatchdog = progressTimeoutMs > 0
             ? setInterval(() => {
                 const turn = this.turn;
                 if (turn === undefined)
                     return;
-                const elapsed = Date.now() - lastStandaloneNoticeAt;
+                const elapsed = Date.now() - lastProgressNoticeAt;
                 if (elapsed < progressTimeoutMs)
                     return;
-                lastStandaloneNoticeAt = Date.now();
+                lastProgressNoticeAt = Date.now();
                 const minutes = Math.max(1, Math.round((Date.now() - turn.startedAt) / 60_000));
                 const status = turn.milestone ?? this.t.progressThinking;
-                void this.adapter
-                    .sendText(this.target(msg), this.t.progressReminder(minutes, status))
-                    .catch(() => undefined);
+                // Edit the existing streaming card in place instead of sending a new
+                // message: the milestone is appended to the same card via the chunk
+                // stream, so progress updates never clutter the chat with new bubbles.
+                turn.chunks.push(`\n\n${this.t.progressReminder(minutes, status)}\n\n`);
             }, PROGRESS_WATCHDOG_CHECK_MS)
             : undefined;
         // End the chunk stream unconditionally: if `followup` / `whenIdle` /
@@ -1320,7 +1020,7 @@ export class AgentRunner {
             }
             case "dir": {
                 if (command.path === undefined) {
-                    await this.openMenu(target, msg, "workspace", ["root"]);
+                    await this.menu.openMenu(target, msg, "workspace", ["root"]);
                     break;
                 }
                 const path = command.path;
@@ -1344,15 +1044,15 @@ export class AgentRunner {
                 break;
             }
             case "chat": {
-                await this.openMenu(target, msg, "chat", ["root"]);
+                await this.menu.openMenu(target, msg, "chat", ["root"]);
                 break;
             }
             case "menu": {
-                await this.openMenu(target, msg, "root");
+                await this.menu.openMenu(target, msg, "root");
                 break;
             }
             case "settings": {
-                await this.openMenu(target, msg, "settings", ["root"]);
+                await this.menu.openMenu(target, msg, "settings", ["root"]);
                 break;
             }
             case "plugins": {
@@ -1384,7 +1084,7 @@ export class AgentRunner {
                 break;
             }
             case "model": {
-                await this.openMenu(target, msg, "model", ["root"]);
+                await this.menu.openMenu(target, msg, "model", ["root"]);
                 break;
             }
             case "notify": {
@@ -1676,198 +1376,12 @@ export class AgentRunner {
         await this.disposeAgent();
     }
     listWorkspaces() {
-        const registry = this.ctx.get("workspaceRegistry");
-        const out = [];
-        const seen = new Set();
-        const add = (path, title) => {
-            if (path === "")
-                return;
-            const key = path.replace(/[\\/]+$/, "").toLowerCase();
-            if (seen.has(key))
-                return;
-            seen.add(key);
-            out.push({ path, title: title || path });
-        };
-        add(this.workDir, this.t.currentDir);
-        for (const w of registry?.list?.() ?? [])
-            add(w.path, w.title);
-        for (const p of this.config.workspaces)
-            add(p, p);
-        return out;
-    }
-    async openMenu(target, msg, menuId, stack = [], cardId) {
-        const items = await this.menuItems(menuId);
-        const options = items.map((i) => ({ id: i.id, label: i.label }));
-        options.push({ id: "menu:exit", label: this.t.menuExit });
-        if (stack.length > 0)
-            options.push({ id: "menu:back", label: this.t.menuBack });
-        // Determine columns per row based on menu type
-        // Workspace and chat lists use 1 column (full width), others use 2 columns
-        const columnsPerRow = (menuId === "workspace" || menuId === "chat") ? 1 : 2;
-        const { choice, messageId } = await this.adapter.promptChoice(target, {
-            title: this.menuTitle(menuId),
-            options,
-            columnsPerRow,
-            ...(menuId === "root" ? { sections: this.rootMenuSections(), footer: this.t.rootMenuFooter } : {}),
-        }, cardId);
-        if (choice === undefined)
-            return;
-        if (choice === "menu:exit") {
-            await this.adapter.closeMenu(messageId, this.t.menuClosed);
-            return;
-        }
-        if (choice === "menu:back") {
-            const parent = stack[stack.length - 1];
-            await this.openMenu(target, msg, parent, stack.slice(0, -1), messageId);
-            return;
-        }
-        const item = items.find((i) => i.id === choice);
-        if (item === undefined) {
-            // The tap belonged to a previous card generation (e.g. a rapid second
-            // tap on the old menu while the new one was still being redrawn). Don't
-            // silently swallow it: redraw the current menu so the chain stays usable.
-            await this.openMenu(target, msg, menuId, stack, messageId);
-            return;
-        }
-        const feedback = await item.onSelect(target, msg, messageId);
-        if (item.leaf === true) {
-            // Every leaf press must answer visibly: send the action's result feedback
-            // (if any) before returning to the root menu on the same card.
-            if (feedback !== undefined && feedback !== "") {
-                await this.adapter.sendText(target, feedback).catch(() => undefined);
-            }
-            await this.openMenu(target, msg, "root", [], messageId);
-        }
-    }
-    async menuItems(menuId) {
-        switch (menuId) {
-            case "root":
-                return [
-                    { id: "workspace", label: this.t.menuWorkspaceAction, onSelect: (t, m, cardId) => this.openMenu(t, m, "workspace", ["root"], cardId) },
-                    { id: "chat", label: this.t.menuChatAction, onSelect: (t, m, cardId) => this.openMenu(t, m, "chat", ["root"], cardId) },
-                    { id: "status", label: this.t.menuStatusAction, leaf: true, onSelect: async (t) => { await this.showStatus(t); } },
-                    { id: "task", label: this.t.menuTaskAction, leaf: true, onSelect: async (t) => { await this.showTasks(t); } },
-                    { id: "history", label: this.t.menuHistoryAction, leaf: true, onSelect: async (t) => { await this.showHistory(t, 10); } },
-                    { id: "goals", label: this.t.menuGoalsAction, leaf: true, onSelect: async (t) => { await this.showGoals(t); } },
-                    { id: "schedule", label: this.t.menuScheduleAction, leaf: true, onSelect: async (t) => { await this.showSchedule(t); } },
-                    { id: "compact", label: this.t.menuCompactAction, leaf: true, onSelect: async (t) => { await this.compact(t); } },
-                    { id: "plugins", label: this.t.menuPluginsAction, leaf: true, onSelect: async (t) => { await this.showPlugins(t); } },
-                    { id: "settings", label: this.t.menuSettingsAction, onSelect: (t, m, cardId) => this.openMenu(t, m, "settings", ["root"], cardId) },
-                ];
-            case "workspace": {
-                const workspaces = this.listWorkspaces();
-                return workspaces.map((w) => ({
-                    id: `dir:${w.path}`,
-                    label: `${w.path === this.workDir ? "● " : ""}${w.title}${w.title !== w.path ? `  (${w.path})` : ""}`,
-                    leaf: true,
-                    onSelect: async (t, m) => {
-                        this.workDir = w.path;
-                        await this.newChat(m);
-                        return this.t.dirSwitched(w.path);
-                    },
-                }));
-            }
-            case "chat": {
-                const binding = this.bindings.get(this.channel, this.chatKey);
-                const active = binding?.sessionId;
-                const hasWebMirror = binding?.webMirrorSessionId !== undefined;
-                const items = (await this.collectWorkdirSessions()).map(({ sessionId, title }) => {
-                    const isMirrored = hasWebMirror && binding?.webMirrorSessionId === sessionId;
-                    const mirrorIndicator = isMirrored ? ` ${this.t.webMirrorIndicator}` : "";
-                    const activeIndicator = sessionId === active ? "●" : "○";
-                    return {
-                        id: `session:${sessionId}`,
-                        label: `${activeIndicator} ${title || sessionId}${mirrorIndicator}`,
-                        leaf: true,
-                        onSelect: async (t, m) => {
-                            await this.switchTo(sessionId, m.senderKey);
-                            return this.t.sessionSwitched(title || sessionId);
-                        },
-                    };
-                });
-                if (items.length === 0) {
-                    items.push({
-                        id: "none:history",
-                        label: this.t.noSessionsInWorkdir(this.workDir),
-                        leaf: true,
-                        onSelect: async () => this.t.noSessionsInWorkdir(this.workDir),
-                    });
-                }
-                items.push({
-                    id: "action:new",
-                    label: this.t.menuNewChat,
-                    leaf: true,
-                    onSelect: async (t, m, messageId) => {
-                        // Reuse the menu card for the confirm prompt so no stale card is left behind.
-                        if (await this.confirmAction(t, this.t.confirmNewText, messageId)) {
-                            await this.newChat(m);
-                            return this.t.newChatDone;
-                        }
-                        return this.t.actionCancelled;
-                    },
-                });
-                return items;
-            }
-            case "settings":
-                return [
-                    { id: "model", label: this.t.menuSettingsModel, onSelect: (t, m, cardId) => this.openMenu(t, m, "model", ["settings", "root"], cardId) },
-                    { id: "reasoning", label: this.t.menuSettingsReasoning, onSelect: (t, m, cardId) => this.openMenu(t, m, "reasoning", ["settings", "root"], cardId) },
-                    { id: "notify", label: this.t.menuSettingsNotify, onSelect: (t, m, cardId) => this.openMenu(t, m, "notify", ["settings", "root"], cardId) },
-                    { id: "progress", label: this.t.menuSettingsProgress, onSelect: (t, m, cardId) => this.openMenu(t, m, "progress", ["settings", "root"], cardId) },
-                    { id: "language", label: this.t.menuSettingsLanguage, onSelect: (t, m, cardId) => this.openMenu(t, m, "language", ["settings", "root"], cardId) },
-                    { id: "overview", label: this.t.menuSettingsOverview, leaf: true, onSelect: async (t) => { await this.showSettings(t); } },
-                ];
-            case "language":
-                return [
-                    {
-                        id: "lang:zh",
-                        label: `${this.language === "zh" ? "● " : ""}${this.t.languageZh}`,
-                        leaf: true,
-                        onSelect: async (t, m) => { await this.setLanguage("zh", t, m); },
-                    },
-                    {
-                        id: "lang:en",
-                        label: `${this.language === "en" ? "● " : ""}${this.t.languageEn}`,
-                        leaf: true,
-                        onSelect: async (t, m) => { await this.setLanguage("en", t, m); },
-                    },
-                ];
-            case "model":
-                return await this.modelMenuItems();
-            case "reasoning":
-                return this.reasoningMenuItems();
-            case "notify":
-                return [
-                    { id: "full", label: this.t.notifyFull },
-                    { id: "important", label: this.t.notifyImportant },
-                    { id: "result", label: this.t.notifyResult },
-                ].map((o) => ({
-                    id: `notify:${o.id}`,
-                    label: `${this.notifyLevel === o.id ? "● " : ""}${o.label}`,
-                    leaf: true,
-                    onSelect: async (t, m) => {
-                        await this.setNotifyLevel(o.id, t, m);
-                    },
-                }));
-            case "progress": {
-                const presets = [
-                    { id: "progress:0", label: this.t.progressOff, ms: 0 },
-                    { id: "progress:120000", label: this.t.progressMinutes(2), ms: 2 * 60_000 },
-                    { id: "progress:300000", label: this.t.progressMinutes(5), ms: 5 * 60_000 },
-                    { id: "progress:600000", label: this.t.progressMinutes(10), ms: 10 * 60_000 },
-                    { id: "progress:900000", label: this.t.progressMinutes(15), ms: 15 * 60_000 },
-                    { id: "progress:1800000", label: this.t.progressMinutes(30), ms: 30 * 60_000 },
-                ];
-                return presets.map((o) => ({
-                    id: o.id,
-                    label: `${this.progressTimeoutMs === o.ms ? "● " : ""}${o.label}`,
-                    leaf: true,
-                    onSelect: async (t, m) => {
-                        await this.setProgressTimeout(o.ms, t, m);
-                    },
-                }));
-            }
-        }
+        return listWorkspaces({
+            registry: this.ctx.get("workspaceRegistry"),
+            workDir: this.workDir,
+            currentDirLabel: this.t.currentDir,
+            workspaces: this.config.workspaces,
+        });
     }
     async showStatus(target) {
         const agent = this.agent;
@@ -1968,41 +1482,6 @@ export class AgentRunner {
         lines.push(this.t.stateDirField(this.config.stateDir ?? ".dsh-connect"));
         await this.adapter.sendText(target, lines.join("\n"));
     }
-    async modelMenuItems() {
-        const choices = await this.listModelChoices();
-        const current = this.defaultSelection();
-        const items = choices.map((c) => ({
-            id: `model:${c.provider}:${c.model}`,
-            label: `${c.provider === current.provider && c.model === current.model ? "● " : ""}${c.name}`,
-            leaf: true,
-            onSelect: async (t, m) => {
-                await this.setModel(c.provider, c.model, m);
-                return this.t.modelSet(c.name);
-            },
-        }));
-        if (items.length === 0) {
-            items.push({ id: "model:none", label: this.t.noModelsFound, leaf: true, onSelect: async () => this.t.noModelsFound });
-        }
-        return items;
-    }
-    async listModelChoices() {
-        const llm = this.ctx.get("llm");
-        const providers = llm?.listProviders?.() ?? [];
-        const out = [];
-        for (const p of providers) {
-            let models = [];
-            try {
-                models = (await llm?.listModels?.(p.id)) ?? [];
-            }
-            catch {
-                // Skip providers whose catalog cannot be listed.
-            }
-            for (const m of models) {
-                out.push({ provider: p.id, model: m.id, name: this.t.modelName(m.name || m.id, p.name || p.id) });
-            }
-        }
-        return out;
-    }
     async setModel(provider, model, msg) {
         const svc = this.ctx.get("agentDefaultModel");
         const cur = this.defaultSelection();
@@ -2013,37 +1492,6 @@ export class AgentRunner {
         });
         await this.newChat(msg);
     }
-    reasoningMenuItems() {
-        const current = this.defaultSelection();
-        const efforts = [
-            { id: "low", name: this.t.effortLow },
-            { id: "medium", name: this.t.effortMedium },
-            { id: "high", name: this.t.effortHigh },
-        ];
-        const items = [
-            {
-                id: "effort:default",
-                label: `${current.reasoningEffort === undefined ? "● " : ""}${this.t.effortDefault}`,
-                leaf: true,
-                onSelect: async (t, m) => {
-                    await this.setReasoning(undefined, m);
-                    return this.t.reasoningSet(this.t.effortDefault);
-                },
-            },
-        ];
-        for (const e of efforts) {
-            items.push({
-                id: `effort:${e.id}`,
-                label: `${e.id === current.reasoningEffort ? "● " : ""}${e.name}`,
-                leaf: true,
-                onSelect: async (t, m) => {
-                    await this.setReasoning(e.id, m);
-                    return this.t.reasoningSet(e.name);
-                },
-            });
-        }
-        return items;
-    }
     async setReasoning(effort, msg) {
         const svc = this.ctx.get("agentDefaultModel");
         const cur = this.defaultSelection();
@@ -2304,18 +1752,7 @@ export class AgentRunner {
         await this.adapter.sendText(target, lines.join("\n"));
     }
     goalPhaseLabel(phase) {
-        switch (phase) {
-            case "active":
-                return this.t.goalPhaseActive;
-            case "paused":
-                return this.t.goalPhasePaused;
-            case "blocked":
-                return this.t.goalPhaseBlocked;
-            case "complete":
-                return this.t.goalPhaseComplete;
-            default:
-                return phase;
-        }
+        return goalPhaseLabel(phase, this.t);
     }
     async showSchedule(target) {
         // Agent-level reminders (session `schedule` tool) + persistent chat-level