moqi-tui 0.2.0

package/lib/tui/export.js

@@ -0,0 +1,48 @@
+/**
+ * Transcript export: turn the in-app message list into a markdown document.
+ *
+ * Pure and free of Harness imports, like everything under `./tui/`, so it can
+ * be tested without a profile.
+ * @module
+ */
+import { messageText } from "./state.js";
+/**
+ * Render a transcript as markdown.
+ *
+ * User turns become `## >`-quoted sections and assistant turns `##` sections.
+ * An assistant turn is written in the order it happened — each tool call as a
+ * checklist line between the prose it came between — because a document that
+ * collects the calls at the end tells you what the agent did but not when, and
+ * the reason it said the next thing is usually what the call returned.
+ */
+export function transcriptMarkdown(messages, title) {
+    const lines = [`# ${title === '' ? 'dsh transcript' : title}`, ''];
+    for (const message of messages) {
+        if (message.role === 'user') {
+            lines.push('## >', '', ...indented(messageText(message)), '');
+            continue;
+        }
+        const label = message.command === undefined ? '' : ` (${message.command.ok ? 'ok' : 'failed'})`;
+        lines.push(`## assistant${label}`, '');
+        if (message.reasoning !== undefined && message.reasoning !== '') {
+            lines.push('<details><summary>thinking</summary>', '', '```', ...message.reasoning.split('\n'), '```', '', '</details>', '');
+        }
+        for (const segment of message.segments) {
+            if (segment.kind === 'text') {
+                if (segment.text.trim() !== '')
+                    lines.push(...segment.text.trim().split('\n'), '');
+                continue;
+            }
+            const tool = segment.tool;
+            const mark = tool.status === 'ok' ? 'x' : tool.status === 'error' ? ' ' : '~';
+            lines.push(`- [${mark}] \`${tool.name}\`${tool.detail === undefined ? '' : ` — ${tool.detail}`}`, '');
+        }
+    }
+    return `${lines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd()}\n`;
+}
+/** Quote a user turn the way an email client quotes a reply. */
+function indented(text) {
+    if (text.trim() === '')
+        return [];
+    return text.split('\n').map((line) => (line === '' ? '>' : `> ${line}`));
+}

package/lib/tui/fleet.js

@@ -0,0 +1,346 @@
+/**
+ * The fleet overview: sessions across every device, in one list.
+ *
+ * This module is pure. It knows nothing about filesystems, SSH, or the
+ * Harness — it takes presence records that someone else collected and turns
+ * them into ordered, rendered rows. That is what keeps the interesting part
+ * (staleness, ranking, what a row says) testable without a second machine.
+ *
+ * The transport is deliberately outside this file: see `src/fleet-sources.ts`.
+ * @module
+ */
+import { displayWidth, padEnd, truncate } from "./text.js";
+import { colGold, colGreen, colMuted, colText, muted, ok, selected, style, warn, } from "./theme.js";
+/** The record version this build writes and accepts. */
+export const PRESENCE_VERSION = 1;
+/**
+ * How long a record may go unrefreshed before its device is presumed gone.
+ *
+ * Generous relative to the heartbeat: a laptop that sleeps mid-turn should
+ * read as `stale` rather than flapping, and a slow SSH round trip must not
+ * make a healthy device look dead.
+ */
+export const DEFAULT_STALE_AFTER_MS = 30_000;
+/** Rank for sorting: what is running matters most, what is gone matters least. */
+const STATUS_RANK = {
+    running: 0,
+    ready: 1,
+    idle: 2,
+    stale: 3,
+};
+/** Whether a record is well-formed enough to display. */
+export function isPresenceRecord(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const record = value;
+    return (record.v === PRESENCE_VERSION &&
+        typeof record.host === 'string' &&
+        record.host !== '' &&
+        typeof record.sessionId === 'string' &&
+        record.sessionId !== '' &&
+        typeof record.updatedAt === 'number' &&
+        Number.isFinite(record.updatedAt) &&
+        (record.status === 'running' || record.status === 'ready' || record.status === 'idle'));
+}
+/**
+ * Merge every device's records into one ordered list.
+ *
+ * A record older than `staleAfterMs` is reported `stale` whatever it claimed:
+ * a device that stopped heartbeating mid-turn would otherwise sit in the
+ * overview claiming to be running forever.
+ */
+export function mergeFleet(sources, now, staleAfterMs = DEFAULT_STALE_AFTER_MS) {
+    const rows = [];
+    const seen = new Set();
+    for (const source of sources) {
+        for (const record of source.records) {
+            if (!isPresenceRecord(record))
+                continue;
+            // One session is owned by one device; a duplicate id is a stale copy.
+            const key = `${record.host}\u0000${record.sessionId}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const age = Math.max(now - record.updatedAt, 0);
+            rows.push({
+                host: record.host,
+                sessionId: record.sessionId,
+                title: record.title,
+                status: age > staleAfterMs ? 'stale' : record.status,
+                model: record.model,
+                cwd: record.cwd,
+                updatedAt: record.updatedAt,
+                local: source.local,
+                ageSeconds: Math.floor(age / 1000),
+            });
+        }
+    }
+    // Grouped by device, because "which machine is this on" is the question the
+    // overview exists to answer, and the renderer prints a heading per device.
+    // Inside a device the most urgent comes first. The global "what needs me"
+    // question is answered by fleetSummary, not by interleaving hosts here.
+    rows.sort((left, right) => {
+        if (left.local !== right.local)
+            return left.local ? -1 : 1;
+        const byHost = left.host.localeCompare(right.host);
+        if (byHost !== 0)
+            return byHost;
+        const byStatus = (STATUS_RANK[left.status] ?? 9) - (STATUS_RANK[right.status] ?? 9);
+        if (byStatus !== 0)
+            return byStatus;
+        return right.updatedAt - left.updatedAt;
+    });
+    return rows;
+}
+/** A compact age: 8s, 4m, 2h, 3d. */
+export function formatAge(seconds) {
+    if (seconds < 60)
+        return `${String(seconds)}s`;
+    if (seconds < 3600)
+        return `${String(Math.floor(seconds / 60))}m`;
+    if (seconds < 86_400)
+        return `${String(Math.floor(seconds / 3600))}h`;
+    return `${String(Math.floor(seconds / 86_400))}d`;
+}
+/** The status mark, matching the marks the session bar already uses. */
+function statusMark(status, spinner) {
+    switch (status) {
+        case 'running':
+            return style(spinner, { fg: colGreen });
+        case 'ready':
+            return style('●', { fg: colGold });
+        case 'idle':
+            return muted('·');
+        case 'stale':
+            return muted('✗');
+    }
+}
+/**
+ * The command that opens a session on the device that owns it.
+ *
+ * A remote session is reached the same way the device itself is: over SSH,
+ * with a TTY, resuming by id. Nothing new is exposed to do it.
+ */
+export function jumpCommand(session, profile = 'tui') {
+    const resume = `dsh --profile ${profile} --resume ${session.sessionId}`;
+    return session.local ? resume : `ssh -t ${session.host} '${resume}'`;
+}
+/**
+ * Quote one argument for a POSIX shell.
+ *
+ * A prompt is arbitrary text and is about to travel through `ssh`, which hands
+ * it to the remote shell — so it is single-quoted with the one escape a single
+ * quoted string has. Nothing here trusts the caller.
+ */
+export function shellQuote(text) {
+    return `'${text.replaceAll("'", "'\\''")}'`;
+}
+/**
+ * The argv for dispatching a task to a peer's headless profile.
+ *
+ * The prompt is quoted for the remote shell; the profile name and host are
+ * passed as separate argv words so the local shell never interprets them.
+ */
+export function dispatchArgv(host, profile, prompt) {
+    return ['-o', 'BatchMode=yes', host, `dsh --profile ${profile} ${shellQuote(prompt)}`];
+}
+/**
+ * Render the overview to styled lines.
+ *
+ * Grouped by device, because "which machine is this on" is the question the
+ * overview exists to answer; an unreachable device is named rather than
+ * silently contributing nothing.
+ */
+export function renderFleet(sessions, options) {
+    const width = Math.max(options.width, 20);
+    // Not the same glyph as `ready`: a caller that forgets to pass an animation
+    // frame must not make a running session look like a finished one.
+    const spinner = options.spinner ?? '⠋';
+    const selectedIndex = options.selectedIndex ?? -1;
+    const out = [];
+    if (sessions.length === 0) {
+        out.push(muted('  no sessions on any device'));
+    }
+    let host = '';
+    sessions.forEach((session, index) => {
+        if (session.host !== host) {
+            host = session.host;
+            if (out.length > 0)
+                out.push('');
+            const label = session.local ? `${host}  (this device)` : host;
+            out.push(style(label, { fg: colText, bold: true }));
+        }
+        const mark = statusMark(session.status, spinner);
+        const age = muted(formatAge(session.ageSeconds));
+        const model = session.model === undefined ? '' : muted(`  ${session.model}`);
+        const title = session.title === '' ? 'new session' : session.title;
+        const head = ` ${mark} ${truncate(title, Math.max(width - 22, 8))}${model}`;
+        const pad = Math.max(width - displayWidth(head) - displayWidth(age) - 1, 1);
+        const row = `${head}${' '.repeat(pad)}${age}`;
+        out.push(index === selectedIndex ? selected(padEnd(row, width)) : row);
+    });
+    for (const source of options.sources ?? []) {
+        if (source.error === undefined)
+            continue;
+        out.push(warn(`  ${source.host}: ${truncate(source.error, Math.max(width - 4, 8))}`));
+    }
+    return out;
+}
+/** A one-line summary for the status bar: how much is running where. */
+export function fleetSummary(sessions) {
+    const running = sessions.filter((session) => session.status === 'running').length;
+    const ready = sessions.filter((session) => session.status === 'ready').length;
+    const hosts = new Set(sessions.map((session) => session.host)).size;
+    const parts = [];
+    if (running > 0)
+        parts.push(`${String(running)} running`);
+    if (ready > 0)
+        parts.push(`${String(ready)} ready`);
+    if (parts.length === 0)
+        parts.push(`${String(sessions.length)} idle`);
+    return `${parts.join(', ')} across ${String(hosts)} device${hosts === 1 ? '' : 's'}`;
+}
+/** Colors re-exported so a caller can match the overview's palette. */
+export const FLEET_COLORS = { colGreen, colGold, colMuted, colText, ok };
+/**
+ * Which rendered line carries row `index`.
+ *
+ * {@link renderFleet} inserts a heading per device and a blank line between
+ * groups, so the selected row's index is not its line. The pane needs the
+ * line to scroll, and duplicating the rule here rather than returning it from
+ * the renderer keeps the renderer a plain function of its inputs. The two must
+ * agree, which is what the smoke test pins.
+ */
+export function fleetLineOf(sessions, index) {
+    let line = 0;
+    let host = '';
+    for (const [position, session] of sessions.entries()) {
+        if (session.host !== host) {
+            host = session.host;
+            // Mirrors renderFleet: a separator before every group but the first.
+            if (line > 0)
+                line += 1;
+            line += 1;
+        }
+        if (position === index)
+            return line;
+        line += 1;
+    }
+    return 0;
+}
+/**
+ * Whether a string is safe and sensible to use as a peer.
+ *
+ * The value ends up on an `ssh` command line, so this is a gate rather than a
+ * tidy-up: anything a shell would treat as more than one word, or that `ssh`
+ * would read as an option, is refused outright instead of being escaped and
+ * hoped for. What remains is the shape of a host, an alias, or `user@host`.
+ */
+export function isValidPeer(host) {
+    const trimmed = host.trim();
+    if (trimmed === '' || trimmed.length > 255)
+        return false;
+    // A leading dash would be parsed by ssh as a flag, not a destination.
+    if (trimmed.startsWith('-'))
+        return false;
+    return /^[A-Za-z0-9_.@:[\]-]+$/.test(trimmed);
+}
+/**
+ * The overview's interaction state: what was collected, and where the cursor is.
+ *
+ * Kept beside the renderer because it is the same concern and equally pure —
+ * it never reads a file or a socket. The app owns collection and hands the
+ * result here.
+ */
+export class FleetView {
+    open = false;
+    /** True while a collection round is in flight, so the pane can say so. */
+    loading = false;
+    sessions = [];
+    sources = [];
+    selected = 0;
+    /**
+     * Set while the pane is asking for a device to add.
+     *
+     * Adding a peer belongs here rather than only on the command line, because
+     * the list is exactly where you notice a device is missing from it.
+     */
+    adding = false;
+    /** What has been typed into that prompt so far. */
+    draft = '';
+    show() {
+        this.open = true;
+        this.loading = true;
+    }
+    hide() {
+        this.open = false;
+        this.loading = false;
+    }
+    /**
+     * Install a freshly collected round.
+     *
+     * The cursor follows the session it was on rather than the position it was
+     * at: rows reorder as work starts and finishes, and a refresh that moved the
+     * selection onto a different machine would be a way to open the wrong thing.
+     */
+    setResult(sessions, sources) {
+        const anchor = this.current()?.sessionId;
+        this.loading = false;
+        this.sessions = [...sessions];
+        this.sources = [...sources];
+        if (anchor !== undefined) {
+            const found = this.sessions.findIndex((session) => session.sessionId === anchor);
+            this.selected = found === -1 ? 0 : found;
+        }
+        this.clamp();
+    }
+    move(delta) {
+        if (this.sessions.length === 0)
+            return;
+        this.selected += delta;
+        this.clamp();
+    }
+    current() {
+        return this.sessions[this.selected];
+    }
+    /** Start asking for a device to add. */
+    beginAdd() {
+        this.adding = true;
+        this.draft = '';
+    }
+    /** Abandon the prompt, leaving the list as it was. */
+    cancelAdd() {
+        this.adding = false;
+        this.draft = '';
+    }
+    typeAdd(text) {
+        if (!this.adding)
+            return;
+        this.draft += text;
+    }
+    backspaceAdd() {
+        if (!this.adding)
+            return;
+        this.draft = this.draft.slice(0, -1);
+    }
+    /**
+     * Finish the prompt, returning the host to add.
+     *
+     * A rejected name leaves the prompt open with the text intact, so a typo is
+     * corrected rather than retyped.
+     */
+    commitAdd() {
+        if (!this.adding)
+            return undefined;
+        const host = this.draft.trim();
+        if (!isValidPeer(host))
+            return undefined;
+        this.adding = false;
+        this.draft = '';
+        return host;
+    }
+    clamp() {
+        const last = this.sessions.length - 1;
+        this.selected = last < 0 ? 0 : Math.min(Math.max(this.selected, 0), last);
+    }
+}

package/lib/tui/i18n.js

@@ -0,0 +1,201 @@
+/**
+ * Interface language: one catalog, looked up by key.
+ *
+ * The scope is deliberate: the chrome a reader reads — the welcome, the key
+ * reference, the trust panels, and the footer hints. Operational status lines
+ * (what a command just did) stay English because they are diagnostics, not
+ * interface, and translating a moving target is how a UI ends up half in each
+ * language.
+ *
+ * A missing key falls back to English and then to the key itself, so a new
+ * string can never render as blank.
+ * @module
+ */
+/** Every language, in menu order, with the label to show in a picker. */
+export const LANGS = [
+    { id: 'en', label: 'English' },
+    { id: 'zh-CN', label: '简体中文' },
+];
+/** Whether an untrusted string names a language this build speaks. */
+export function isLang(value) {
+    return LANGS.some((entry) => entry.id === value);
+}
+const EN = {
+    'welcome.title': '◆  DeepSeek Harness',
+    'welcome.connected': 'connected to {host}  ·  {model}',
+    'welcome.harness': 'sessions, compaction and tools live in the harness',
+    'welcome.type': 'type a message, or ',
+    'welcome.forCommands': ' for commands',
+    'footer.hint': '/ commands  ·  ? help  ·  ctrl+c menu',
+    'footer.scrolled': '↑ {lines} line{s}  ·  ctrl+g newest',
+    'footer.recording': '{spinner} ● recording  ·  ctrl+v stop  ·  esc cancel',
+    'footer.transcribing': '{spinner} transcribing…',
+    'approval.title': 'Allow {tool}?',
+    'approval.allow': 'Allow once',
+    'approval.allowDetail': 'run this one call',
+    'approval.deny': 'Deny',
+    'approval.denyDetail': 'the agent is told no',
+    'approval.hint': '↑↓ move · enter choose · 1 allow · 2 deny · esc denies',
+    'questions.title': 'Question',
+    'questions.of': 'Question {n} of {total}',
+    'questions.answer': 'Answer',
+    'questions.answerPlaceholder': '(type an answer)',
+    'questions.hint': '↑↓ move · enter choose · tab type an answer · esc back',
+    'questions.hintMulti': '↑↓ move · space toggle · enter next · tab type an answer · esc back',
+    'questions.hintPlan': '↑↓ move · enter decide · type feedback to keep planning · esc back',
+    'questions.cancelSuffix': ' · esc cancels',
+    'help.body': [
+        '**Keys**',
+        '',
+        '- `enter` — send · steers into a running reply · `ctrl+j` — newline',
+        '- `↑` / `↓` on the first / last row — recall earlier prompts',
+        '- `/` — command palette · `tab` accept · `esc` dismiss',
+        '- `@` — file completion · `tab`/`enter` accept · `esc` dismiss',
+        '- `esc` — clear a search, else interrupt a reply while it is streaming',
+        '- `tab` while streaming queues · `/unqueue` discards · `/interrupt` runs them',
+        '- `ctrl+n` — new session · `ctrl+r` — resume · `ctrl+t` — toggle thinking',
+        '- `pgup` / `pgdn` — page · `shift+↑` / `shift+↓` — one line · `ctrl+g` — newest',
+        '- `ctrl+↑` / `ctrl+↓` — half page · `ctrl+u` — clear the composer',
+        '- `alt+e` — edit draft · `alt+↑`/`alt+↓` select a turn · `alt+c` — copy it',
+        '- `ctrl+o` — tool calls · `ctrl+x` — compact · `ctrl+b` — background agents',
+        '- `ctrl+y` — copy the last reply · `ctrl+f` — every device · `ctrl+v` — push to talk',
+        '- `?` — open this help on an empty composer',
+        '',
+        '**Sessions**',
+        '',
+        '- `ctrl+n` — new session · `alt+1`…`alt+9` jump · `tab` on empty cycles · `/sessions` picks',
+        '- `/close` · `/rename <t>` · `/rewind` redo · `/fork` twin · `/tree` lineage · `/jobs`',
+        '- `ctrl+a` / `ctrl+e` — start / end of line · `ctrl+w` — delete word · `ctrl+d` — delete forward',
+        '',
+        '**Fleet** (`ctrl+f`, `/fleet`) — every device running this app, by machine',
+        '',
+        '- `↑`/`↓` move · `r` refresh · `enter` open · `p` preview · `d` dispatch · `esc` back',
+        '- a session elsewhere copies the `ssh` that reaches it; `--peer <host>` adds one',
+        '',
+        '**Plugins** (`/plugins`) — the packages this profile composes',
+        '',
+        '- `enter` — enable or disable the selected package · restart to apply',
+        '- `/plugins add|remove <pkg>` — both confirm; install scripts run as you',
+        '',
+        '**Searching, palettes and lists**',
+        '',
+        '- `/find <text>` — search · `n` / `N` on an empty composer — next / previous',
+        '- `/find --sessions <text>` — search every stored session on this machine',
+        '- `/theme` — pick a palette · `mono` is greyscale · in a list: type to filter',
+        '',
+        '**Decisions** — when the agent stops to ask, the panel owns the keyboard',
+        '',
+        '- approval: `1` allow once · `2` / `esc` deny · questions: `↑`/`↓`, `space`, `enter`, `tab`',
+        '- plan review: `enter` approves or keeps planning · typing is feedback',
+        '',
+        '**Commands**',
+        '',
+        'Type `/` for every command the harness has registered, its own plugins too.',
+        '',
+        '- `ctrl+c` — sessions menu · again within 1.5s — quit',
+    ].join('\n'),
+};
+const ZH = {
+    'welcome.title': '◆  DeepSeek Harness',
+    'welcome.connected': '已连接 {host}  ·  {model}',
+    'welcome.harness': '会话、压缩与工具都在 harness 中',
+    'welcome.type': '输入消息，或用 ',
+    'welcome.forCommands': ' 打开命令',
+    'footer.hint': '/ 命令  ·  ? 帮助  ·  ctrl+c 菜单',
+    'footer.scrolled': '↑ {lines} 行  ·  ctrl+g 回到最新',
+    'footer.recording': '{spinner} ● 正在录音  ·  ctrl+v 停止  ·  esc 取消',
+    'footer.transcribing': '{spinner} 正在转写…',
+    'approval.title': '允许 {tool}？',
+    'approval.allow': '允许一次',
+    'approval.allowDetail': '只运行这一次调用',
+    'approval.deny': '拒绝',
+    'approval.denyDetail': '告诉 agent 不行',
+    'approval.hint': '↑↓ 移动 · enter 选择 · 1 允许 · 2 拒绝 · esc 拒绝',
+    'questions.title': '提问',
+    'questions.of': '第 {n} / {total} 个问题',
+    'questions.answer': '回答',
+    'questions.answerPlaceholder': '（输入回答）',
+    'questions.hint': '↑↓ 移动 · enter 选择 · tab 输入回答 · esc 返回',
+    'questions.hintMulti': '↑↓ 移动 · space 多选 · enter 下一个 · tab 输入回答 · esc 返回',
+    'questions.hintPlan': '↑↓ 移动 · enter 决定 · 直接输入即为反馈 · esc 返回',
+    'questions.cancelSuffix': ' · esc 取消',
+    'help.body': [
+        '**按键**',
+        '',
+        '- `enter` — 发送 · 回复中则插入运行中的回合 · `ctrl+j` — 换行',
+        '- 首行 / 末行的 `↑` / `↓` — 调出历史提示词',
+        '- `/` — 命令面板 · `tab` 接受 · `esc` 关闭',
+        '- `@` — 文件补全 · `tab`/`enter` 接受 · `esc` 关闭',
+        '- `esc` — 先清搜索，否则打断正在流式的回复',
+        '- 流式中 `tab` 排队 · `/unqueue` 丢弃 · `/interrupt` 立即执行',
+        '- `ctrl+n` — 新会话 · `ctrl+r` — 恢复 · `ctrl+t` — 思考显示',
+        '- `pgup` / `pgdn` — 翻页 · `shift+↑` / `shift+↓` — 一行 · `ctrl+g` — 最新',
+        '- `ctrl+↑` / `ctrl+↓` — 半页 · `ctrl+u` — 清空输入框',
+        '- `alt+e` — 外部编辑器 · `alt+↑`/`alt+↓` 选中回合 · `alt+c` — 复制',
+        '- `ctrl+o` — 工具调用 · `ctrl+x` — 压缩 · `ctrl+b` — 后台 agent',
+        '- `ctrl+y` — 复制上一条回复 · `ctrl+f` — 所有设备 · `ctrl+v` — 语音输入',
+        '- 输入框为空时 `?` — 打开本帮助',
+        '',
+        '**会话**',
+        '',
+        '- `ctrl+n` — 新会话 · `alt+1`…`alt+9` 跳转 · 空输入框 `tab` 循环 · `/sessions` 选择',
+        '- `/close` · `/rename <标题>` · `/rewind` 重来 · `/fork` 分身 · `/tree` 谱系 · `/jobs`',
+        '- `ctrl+a` / `ctrl+e` — 行首 / 行尾 · `ctrl+w` — 删词 · `ctrl+d` — 向后删除',
+        '',
+        '**舰队**（`ctrl+f`、`/fleet`）— 每台运行本应用的机器',
+        '',
+        '- `↑`/`↓` 移动 · `r` 刷新 · `enter` 打开 · `p` 预览 · `d` 下发任务 · `esc` 返回',
+        '- 其他设备上的会话会复制出可达的 `ssh` 命令；`--peer <主机>` 添加设备',
+        '',
+        '**插件**（`/plugins`）— 该 profile 组合的软件包',
+        '',
+        '- `enter` — 启用或停用所选包 · 重启后生效',
+        '- `/plugins add|remove <包>` — 都会确认；安装脚本以你的身份运行',
+        '',
+        '**搜索、配色与列表**',
+        '',
+        '- `/find <文本>` — 搜索 · 空输入框 `n` / `N` — 下一个 / 上一个',
+        '- `/find --sessions <文本>` — 搜索本机所有已存储会话',
+        '- `/theme` — 选择配色 · `mono` 为灰度 · 列表中输入即筛选',
+        '',
+        '**需要决定时** — 面板接管键盘',
+        '',
+        '- 审批：`1` 允许一次 · `2` / `esc` 拒绝 · 提问：`↑`/`↓`、`space`、`enter`、`tab`',
+        '- 计划审核：`enter` 批准或继续规划 · 直接输入即为反馈',
+        '',
+        '**命令**',
+        '',
+        '输入 `/` 查看 harness 注册的全部命令，包括其插件。',
+        '',
+        '- `ctrl+c` — 会话菜单 · 1.5 秒内再次按下 — 退出',
+    ].join('\n'),
+};
+const CATALOGS = { en: EN, 'zh-CN': ZH };
+/** Fill `{name}` placeholders; a missing value leaves the placeholder alone. */
+export function fill(template, params) {
+    if (params === undefined)
+        return template;
+    return template.replace(/\{(\w+)\}/g, (whole, key) => Object.prototype.hasOwnProperty.call(params, key) ? String(params[key]) : whole);
+}
+/** Look a string up in one explicit language. */
+export function translate(lang, key, params) {
+    const template = CATALOGS[lang]?.[key] ?? EN[key] ?? key;
+    return fill(template, params);
+}
+let active = 'en';
+/** The language the interface is drawing in. */
+export function currentLanguage() {
+    return active;
+}
+/** Switch the interface language; the caller persists the choice. */
+export function setLanguage(lang) {
+    active = lang;
+}
+/** Look a string up in the active language. */
+export function t(key, params) {
+    return translate(active, key, params);
+}
+/** The full key reference in the active language. */
+export function helpText() {
+    return t('help.body');
+}

package/lib/tui/jobs.js

@@ -0,0 +1,65 @@
+/**
+ * `/jobs` formatting: a background job list rendered as markdown.
+ *
+ * Pure, like the rest of `tui/`: the app layer hands over snapshots and owns
+ * the registry calls.
+ * @module
+ */
+/** A compact "3s" / "4m" / "2h" duration. */
+export function formatDuration(seconds) {
+    if (seconds < 60)
+        return `${String(Math.max(Math.floor(seconds), 0))}s`;
+    if (seconds < 3600)
+        return `${String(Math.floor(seconds / 60))}m`;
+    if (seconds < 86400)
+        return `${String(Math.floor(seconds / 3600))}h`;
+    return `${String(Math.floor(seconds / 86400))}d`;
+}
+/** The mark a job's state earns in the list. */
+export function jobMark(status) {
+    if (status === 'running')
+        return '⠹';
+    if (status === 'stopping')
+        return '⠴';
+    if (status === 'completed')
+        return '✓';
+    if (status === 'killed')
+        return '·';
+    return '✗';
+}
+/**
+ * The `/jobs` overlay body.
+ *
+ * Running jobs first, then the settled ones newest-first, because the list
+ * exists to answer "what is still going" before "what happened".
+ */
+export function renderJobs(jobs, now = Date.now()) {
+    if (jobs.length === 0) {
+        return ['**Background jobs**', '', 'Nothing has run in the background in this session.'].join('\n');
+    }
+    const running = jobs.filter((job) => job.status === 'running' || job.status === 'stopping');
+    const settled = jobs
+        .filter((job) => job.status !== 'running' && job.status !== 'stopping')
+        .sort((a, b) => (b.finishedAt ?? b.startedAt) - (a.finishedAt ?? a.startedAt));
+    const lines = ['**Background jobs**', ''];
+    const row = (job) => {
+        const end = job.finishedAt ?? now;
+        const duration = formatDuration((end - job.startedAt) / 1000);
+        const detail = job.detail === undefined || job.detail === '' ? '' : ` — ${job.detail}`;
+        return `- ${jobMark(job.status)} \`${job.id}\` ${job.kind}: ${job.label}${detail} · ${job.status} ${duration}`;
+    };
+    if (running.length > 0) {
+        lines.push(`Running (${String(running.length)})`, '');
+        for (const job of running)
+            lines.push(row(job));
+        lines.push('');
+    }
+    if (settled.length > 0) {
+        lines.push(`Finished (${String(settled.length)})`, '');
+        for (const job of settled)
+            lines.push(row(job));
+        lines.push('');
+    }
+    lines.push('`/jobs kill <id>` stops one · esc closes');
+    return lines.join('\n');
+}