From f5641f9c6f8a39d6b85b2e01c324ebdc8b8d773d Mon Sep 17 00:00:00 2001 From: Mr0Bread <55754540+Mr0Bread@users.noreply.github.com> Date: Sun, 15 Nov 2026 15:55:09 +0200 Subject: [PATCH] feat(agents): say what the agent is doing in the working status, with opt-in playful words (#3459) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The row under a working conversation showed a constant Working…. It now follows the turn's latest entry: Thinking…, Writing…, Reading…, Editing…, Running a command…, Running a subagent… and so on, with Working… for the rest. Settings › Agents › Working Status adds playful words per activity, off by default. When on, they rotate from the start or after a configurable quiet time (0–600 s). Each word stays 8 s, or at least 3 s once the activity changes. Screen readers keep hearing the plain status. Users can replace or clear each activity's words. Co-authored-by: Mr0Bread <55754540+Mr0Bread@users.noreply.github.com> --- crates/ide-core/src/settings.rs | 13 ++ docs/en/guide/agents.mdx | 2 + docs/zh/guide/agents.mdx | 2 + e2e/agentScroll.spec.ts | 4 +- src/bindings.ts | 24 +++ src/features/agents/Session.module.css | 10 ++ src/features/agents/SessionEditor.tsx | 70 +++++++- src/features/agents/WorkingStatus.module.css | 73 ++++++++ src/features/agents/WorkingStatusPage.tsx | 147 ++++++++++++++++ src/features/agents/agentSettings.ts | 3 + src/features/agents/index.ts | 10 ++ src/features/agents/model.ts | 2 + src/features/agents/sessionState.test.tsx | 122 +++++++++++++- src/features/agents/workingStatus.ts | 158 ++++++++++++++++++ .../agents/workingStatusPage.test.tsx | 83 +++++++++ .../settings/__tests__/agents.test.ts | 19 +++ src/features/settings/model/schema.ts | 16 ++ src/platform/agentStatus.ts | 2 + src/platform/locales/text/en.json | 71 +++++++- src/platform/locales/text/zh.json | 71 +++++++- 20 files changed, 894 insertions(+), 8 deletions(-) create mode 100644 src/features/agents/WorkingStatus.module.css create mode 100644 src/features/agents/WorkingStatusPage.tsx create mode 100644 src/features/agents/workingStatus.ts create mode 100644 src/features/agents/workingStatusPage.test.tsx create mode 100644 src/platform/agentStatus.ts diff --git a/crates/ide-core/src/settings.rs b/crates/ide-core/src/settings.rs index e9855f598..9cf26b244 100644 --- a/crates/ide-core/src/settings.rs +++ b/crates/ide-core/src/settings.rs @@ -88,6 +88,16 @@ pub struct AgentSettings { pub smooth_text: bool, /// Conversations and the composer expand to the full width of the pane instead of staying in a centred column. pub fit_window_width: bool, + /// While the agent works, playful words fill the pauses in what it reports. + pub playful_status: bool, + /// Seconds the agent reports nothing new before the playful words take over; 0 shows them + /// from the start. + pub playful_after_seconds: u32, + /// The user's playful words by activity (`working`, `thinking`, `reading`, …), replacing + /// the built-in ones of that activity; an empty list keeps its status factual. + #[serde(deserialize_with = "or_default")] + #[specta(type = BTreeMap>)] + pub playful_words: BTreeMap>, #[serde(deserialize_with = "or_default")] #[specta(type = ThinkingDisplay)] pub thinking: ThinkingDisplay, @@ -130,6 +140,9 @@ impl Default for AgentSettings { fold_turns: true, smooth_text: true, fit_window_width: false, + playful_status: false, + playful_after_seconds: 0, + playful_words: BTreeMap::new(), thinking: ThinkingDisplay::Auto, tool_calls: ToolCallDisplay::Grouped, expand_tool_output: false, diff --git a/docs/en/guide/agents.mdx b/docs/en/guide/agents.mdx index 6d13e220f..b897ce3a8 100644 --- a/docs/en/guide/agents.mdx +++ b/docs/en/guide/agents.mdx @@ -119,6 +119,8 @@ Tasks are saved per project and survive restarts. When the agent supports resumi **Settings › Tools › Agents › Chat** chooses what the task header shows: **Context window usage**, **Time spent on the task**, **Usage limits** (when the agent reports them, such as Claude Code) and **Session cost**. +While the agent works, the line under the conversation says what it is doing: thinking, reading, editing, running a command, writing its reply. **Settings › Agents › Working Status** can show playful words for what it does there instead; they are off by default. Once turned on, they take turns from the moment the work changes, or only after the agent reports nothing new for a number of seconds (0 to 600, 0 by default); screen readers still hear what the agent is doing. Each word stays eight seconds while the agent keeps at the same work, and at least three when it moves on, so the line doesn't flicker. The same page replaces the words: pick what the status says (**Reading…**, **Running a command…**…) and add or remove its words. **Restore Built-in Words** brings back OpenIDEA's; an activity left without words keeps its plain status. + ## Add a custom agent Any agent that speaks ACP over stdio can be added with an agent file, `agents/.toml` in OpenIDEA's configuration directory: diff --git a/docs/zh/guide/agents.mdx b/docs/zh/guide/agents.mdx index b624fbc7d..a867ae69c 100644 --- a/docs/zh/guide/agents.mdx +++ b/docs/zh/guide/agents.mdx @@ -119,6 +119,8 @@ agent 运行过一个任务后,新任务会以它自动批准所有操作的 **设置 › 工具 › 智能体 › 聊天** 决定任务标题栏显示哪些信息:**上下文窗口用量**、**任务耗时**、**用量限额**(agent 报告时,例如 Claude Code)和 **会话花费**。 +agent 工作时,对话下方的状态行显示它正在做什么:思考、读取、编辑、运行命令、输出回复。在 **设置 › 智能体 › 工作状态** 中可以让这里改为显示与当前工作相关的趣味文字,默认关闭。开启后,工作一变化就轮换显示,也可以设置在 agent 无新进展多少秒后才显示(0 到 600,默认 0);屏幕阅读器读出的仍是 agent 实际在做的事。agent 持续做同一类工作时,每条文字停留八秒;转向其他工作时也至少停留三秒,状态行不会频繁跳动。同一页面还可以替换这些文字:选择状态(**正在读取…**、**正在运行命令…**…),再添加或移除对应的文字。**恢复内置文字** 会换回 OpenIDEA 自带的文字;没有任何文字的状态只显示实际进展。 + ## 添加自定义 agent 任何通过 stdio 使用 ACP 的 agent,都可以用一个 agent 文件添加:OpenIDEA 配置目录下的 `agents/.toml`。 diff --git a/e2e/agentScroll.spec.ts b/e2e/agentScroll.spec.ts index d0692c4e5..aa2929ef5 100644 --- a/e2e/agentScroll.spec.ts +++ b/e2e/agentScroll.spec.ts @@ -83,8 +83,8 @@ for (const placement of ["editor", "toolWindow"] as const) { }, { id: task.id, placement }, ); - // The working indicator ends the conversation, after its rows. - await expect(stream.getByRole("status").getByText("Working…", { exact: true })).toBeVisible(); + // The working indicator ends the conversation, after its rows; the turn ends with a reply. + await expect(stream.getByRole("status").getByText("Writing…", { exact: true })).toBeVisible(); await expect(stream.locator(":scope > *")).toHaveCount(80 * 3 + 1); await expect.poll(() => stream.evaluate((el) => el.scrollHeight - el.clientHeight - el.scrollTop)).toBeLessThan(2); const timer = await page.evaluate(async (id) => { diff --git a/src/bindings.ts b/src/bindings.ts index 9f2c20514..e4926f2ca 100644 --- a/src/bindings.ts +++ b/src/bindings.ts @@ -2264,6 +2264,18 @@ export type AgentSettings_Deserialize = { smoothText?: boolean, /** Conversations and the composer expand to the full width of the pane instead of staying in a centred column. */ fitWindowWidth?: boolean, + /** While the agent works, playful words fill the pauses in what it reports. */ + playfulStatus?: boolean, + /** + * Seconds the agent reports nothing new before the playful words take over; 0 shows them + * from the start. + */ + playfulAfterSeconds?: number, + /** + * The user's playful words by activity (`working`, `thinking`, `reading`, …), replacing + * the built-in ones of that activity; an empty list keeps its status factual. + */ + playfulWords?: { [key in string]: string[] }, thinking?: ThinkingDisplay, toolCalls?: ToolCallDisplay, /** A tool call's output (a command's, a diff) is shown without opening it. */ @@ -2304,6 +2316,18 @@ export type AgentSettings_Serialize = { smoothText: boolean, /** Conversations and the composer expand to the full width of the pane instead of staying in a centred column. */ fitWindowWidth: boolean, + /** While the agent works, playful words fill the pauses in what it reports. */ + playfulStatus: boolean, + /** + * Seconds the agent reports nothing new before the playful words take over; 0 shows them + * from the start. + */ + playfulAfterSeconds: number, + /** + * The user's playful words by activity (`working`, `thinking`, `reading`, …), replacing + * the built-in ones of that activity; an empty list keeps its status factual. + */ + playfulWords: { [key in string]: string[] }, thinking: ThinkingDisplay, toolCalls: ToolCallDisplay, /** A tool call's output (a command's, a diff) is shown without opening it. */ diff --git a/src/features/agents/Session.module.css b/src/features/agents/Session.module.css index d8b77c0ba..5e46f22bb 100644 --- a/src/features/agents/Session.module.css +++ b/src/features/agents/Session.module.css @@ -1031,6 +1031,16 @@ color: var(--fg-muted); } +/* Announced to screen readers, not shown: the fact behind a playful status. */ +.srOnly { + position: absolute; + width: 1px; + height: 1px; + overflow: hidden; + clip-path: inset(50%); + white-space: nowrap; +} + .retrying { color: var(--warning); } diff --git a/src/features/agents/SessionEditor.tsx b/src/features/agents/SessionEditor.tsx index 04fd4cbfb..41327f268 100644 --- a/src/features/agents/SessionEditor.tsx +++ b/src/features/agents/SessionEditor.tsx @@ -86,6 +86,16 @@ import { ImagePreview, imageSrc } from "./ImagePreview"; import { useAgentSettings } from "./agentSettings"; import { foldedTurns, summarizeWork, workParts, type FoldedTurn, type WorkSummary } from "./timeline"; import { useRevealedText } from "./reveal"; +import { + ACTIVITY_STATUS, + PLAYFUL_MIN_MS, + PLAYFUL_WORD_MS, + PLAYFUL_WORDS, + activityOf, + playfulIndex, + progressKey, + type Activity, +} from "./workingStatus"; import { AgentReply, MessageActions, ReplyActions } from "./AgentReply"; import { commandPrefix, @@ -2685,27 +2695,81 @@ function WorkingRow({ return (
- {subagent.status === "needsInput" ? "Waiting for your answer…" : "Working…"} + {subagent.status === "needsInput" ? ( + Waiting for your answer… + ) : ( + + )} {subagent.startedMs != null && }
); } if (task.status !== "running" && task.status !== "starting") return null; if (entries?.some((e) => e.type === "permission" && !e.chosen && !e.questions?.length)) return null; - const lastUser = entries?.findLast((e): e is UserEntry => e.type === "user"); + const userAt = entries?.findLastIndex((e) => e.type === "user") ?? -1; + const lastUser = userAt >= 0 ? (entries![userAt] as UserEntry) : undefined; return (
{task.retry ? ( + ) : task.status === "starting" ? ( + Starting the agent… ) : ( - {task.status === "starting" ? "Starting the agent…" : "Working…"} + )} {lastUser?.sentMs != null && !lastUser.doneMs && }
); } +/** + * What the agent is doing, said by the activity's playful words in turns (the user's own, else the + * built-in ones) from the start, or once it has reported nothing new for the user's quiet time; + * screen readers hear only the fact. A word stays its full time while it still fits what the agent + * does, and a little while when it no longer does, so the row never flickers. + */ +function WorkingLabel({ turn, seed }: { turn: AgentEntry[]; seed: number }) { + const tx = useTx(); + const { playfulStatus, playfulAfterSeconds, playfulWords } = useAgentSettings(); + const now = useNow(1000); + const key = progressKey(turn); + const [progress, setProgress] = useState({ key, at: now }); + if (progress.key !== key) setProgress({ key, at: now }); + // The word on screen, and how many the turn has shown, so the next one continues the order. + const [playful, setPlayful] = useState<{ shown: number; word: PlayfulWord | null }>({ shown: 0, word: null }); + const activity = activityOf(turn); + const kind = activity ?? "working"; + const fact = tx(ACTIVITY_STATUS[kind]); + const own = playfulWords[kind]; + const words = own ?? PLAYFUL_WORDS[kind]; + const due = words.length > 0 && (!activity || now - progress.at >= playfulAfterSeconds * 1000); + const current = playful.word; + const fits = due && current?.kind === kind; + const stays = current && playfulStatus && now - current.since < (fits ? PLAYFUL_WORD_MS : PLAYFUL_MIN_MS); + let next = playful; + if (!stays && playfulStatus && due) { + const text = words[playfulIndex(words.length, seed, playful.shown)]!; + next = { shown: playful.shown + 1, word: { text, kind, own: !!own, since: now } }; + } else if (!stays && current) next = { shown: playful.shown, word: null }; + if (next !== playful) setPlayful(next); + if (!next.word) return fact; + return ( + <> + {next.word.own ? next.word.text : tx(next.word.text)} + {fact} + + ); +} + +/** A playful word for `kind` on screen since `since`: the user's own as written, else a built-in one to translate. */ +interface PlayfulWord { + text: string; + kind: Activity; + own: boolean; + since: number; +} + /** The approval the agent waits for, with its answers on 1, 2, 3… */ function PendingPermission({ task, entry }: { task: AgentTask; entry: PermissionEntry }) { const ref = useRef(null); diff --git a/src/features/agents/WorkingStatus.module.css b/src/features/agents/WorkingStatus.module.css new file mode 100644 index 000000000..aedb4c3a6 --- /dev/null +++ b/src/features/agents/WorkingStatus.module.css @@ -0,0 +1,73 @@ +.body { + display: flex; + flex-direction: column; + gap: 10px; + height: 100%; + min-height: 0; +} + +.notice { + margin: 0; + color: var(--fg-muted); + font-size: var(--fs-small); + overflow-wrap: anywhere; +} + +.activity { + display: flex; + align-items: center; + gap: 8px; +} + +.after { + display: flex; + align-items: center; + gap: 8px; +} + +.seconds { + width: 64px; + font-variant-numeric: tabular-nums; +} + +.items { + flex: 1; + min-height: 120px; + display: flex; + flex-direction: column; + gap: 4px; + padding: 8px; + overflow: auto; + border: 1px solid var(--border-strong); + border-radius: var(--radius-control); +} + +.item { + display: flex; + align-items: center; + justify-content: space-between; + gap: 6px; + padding: 4px 8px; + background: var(--bg-subtle); + border-radius: var(--radius-control); +} + +.word { + overflow-wrap: anywhere; +} + +.empty { + color: var(--fg-muted); + font-size: var(--fs-small); +} + +.add { + display: flex; + align-items: center; + gap: 6px; +} + +.input { + flex: 1; + min-width: 0; +} diff --git a/src/features/agents/WorkingStatusPage.tsx b/src/features/agents/WorkingStatusPage.tsx new file mode 100644 index 000000000..e5e57c3a1 --- /dev/null +++ b/src/features/agents/WorkingStatusPage.tsx @@ -0,0 +1,147 @@ +/** + * Settings › Agents › Working Status: whether the status under a conversation turns playful, after + * how long without news, and the playful words of each activity, the built-in ones until the user + * writes their own. + */ +import { useId, useState } from "react"; +import { useTx } from "@/platform/i18n"; +import { PLAYFUL_AFTER_LIMITS } from "@/platform/agentStatus"; +import { Button, Checkbox, IconButton, Input, Select, T, type SelectOption } from "@/ui"; +import { useSettingsForm } from "@/workbench/contributions"; +import { AGENT_SETTINGS_DEFAULTS } from "./agentSettings"; +import { ACTIVITIES, ACTIVITY_STATUS, PLAYFUL_WORDS, type Activity } from "./workingStatus"; +import styles from "./WorkingStatus.module.css"; + +export function WorkingStatusPage() { + const tx = useTx(); + const form = useSettingsForm(); + const playful = + (form.useValue("agents.playfulStatus") as boolean | undefined) ?? AGENT_SETTINGS_DEFAULTS.playfulStatus; + const own = (form.useValue("agents.playfulWords") ?? {}) as Record; + const [activity, setActivity] = useState("working"); + const [draft, setDraft] = useState(""); + const selectId = useId(); + const custom = own[activity]; + const words = custom ?? PLAYFUL_WORDS[activity].map((w) => tx(w)); + + const options: SelectOption[] = ACTIVITIES.map((a) => ({ + value: a, + label: ACTIVITY_STATUS[a], + detail: own[a] ? "Custom" : undefined, + })); + const setWords = (next: string[] | null) => { + const others = Object.fromEntries(Object.entries(own).filter(([a]) => a !== activity)); + form.set("agents.playfulWords", next ? { ...others, [activity]: next } : others); + }; + const add = () => { + const word = draft.trim(); + if (!word) return; + setDraft(""); + if (!words.includes(word)) setWords([...words, word]); + }; + + return ( +
+

+ + While the agent works, the line under the conversation says what it is doing. With playful words on, words for + what it does take turns there instead, from the start or once it reports nothing new for a while; screen + readers still hear the plain status. + +

+ form.set("agents.playfulStatus", on)} + label="Playful words while the agent works" + /> + +
+ + setDraft(e.target.value)} + onKeyDown={(e) => { + if (e.key !== "Enter") return; + // Enter adds the word; it does not press the dialog's OK. + e.preventDefault(); + add(); + }} + placeholder={tx("e.g. Reticulating splines…")} + aria-label={tx("New playful word")} + /> + + +
+
+ ); +} + +/** Seconds without news before the status turns playful; invalid text is flagged and reverted on blur. */ +function PlayfulAfter({ disabled }: { disabled: boolean }) { + const tx = useTx(); + const form = useSettingsForm(); + const value = + (form.useValue("agents.playfulAfterSeconds") as number | undefined) ?? AGENT_SETTINGS_DEFAULTS.playfulAfterSeconds; + const [draft, setDraft] = useState(null); + const id = useId(); + const { min, max } = PLAYFUL_AFTER_LIMITS; + const parse = (text: string) => { + const n = /^\s*\d+\s*$/.test(text) ? Number(text) : NaN; + return n >= min && n <= max ? n : null; + }; + const invalid = draft !== null && parse(draft) === null; + return ( +
+ + { + setDraft(e.target.value); + const n = parse(e.target.value); + if (n !== null) form.set("agents.playfulAfterSeconds", n); + }} + onBlur={() => setDraft(null)} + /> + seconds +
+ ); +} diff --git a/src/features/agents/agentSettings.ts b/src/features/agents/agentSettings.ts index c71fd0d16..fa421ccf9 100644 --- a/src/features/agents/agentSettings.ts +++ b/src/features/agents/agentSettings.ts @@ -13,6 +13,9 @@ export const AGENT_SETTINGS_DEFAULTS: ResolvedAgentSettings = { foldTurns: true, smoothText: true, fitWindowWidth: false, + playfulStatus: false, + playfulAfterSeconds: 0, + playfulWords: {}, thinking: "auto", toolCalls: "grouped", expandToolOutput: false, diff --git a/src/features/agents/index.ts b/src/features/agents/index.ts index 43cd8bb82..e55f2f7cc 100644 --- a/src/features/agents/index.ts +++ b/src/features/agents/index.ts @@ -32,6 +32,7 @@ import { SESSION_KIND, TASK_DRAG, TOOL_WINDOW, + WORKING_STATUS_PAGE, providerIcon, } from "./model"; import { sendPaths, sendSelection, trackEditorCopies } from "./references"; @@ -65,6 +66,15 @@ export function activateSettingsPages(): () => void { keywords: ["agent", "acp", "registry", "install", "update", "coding agent"], component: lazyComponent(() => import("./AgentRegistryPage").then((m) => m.AgentRegistryPage)), }), + registerSettingsPage({ + id: WORKING_STATUS_PAGE, + title: "Working Status", + group: AGENTS_GROUP, + // After Chat. + order: 465, + keywords: ["agent", "status", "playful", "words", "working", "spinner", "fun", "delay", "seconds"], + component: lazyComponent(() => import("./WorkingStatusPage").then((m) => m.WorkingStatusPage)), + }), registerSettingsPage({ id: MCP_PAGE, title: "External MCP Servers", diff --git a/src/features/agents/model.ts b/src/features/agents/model.ts index 2b7046241..fdfba2e94 100644 --- a/src/features/agents/model.ts +++ b/src/features/agents/model.ts @@ -15,6 +15,8 @@ export const AGENTS_GROUP = "Agents"; export const MCP_PAGE = "agents.mcpServers"; /** Settings › Agents › Command Permissions. */ export const POLICY_PAGE = "agents.policy"; +/** Settings › Agents › Working Status: the playful words under a working conversation. */ +export const WORKING_STATUS_PAGE = "agents.workingStatus"; export const sessionKey = (task: string) => `agent:${task}`; diff --git a/src/features/agents/sessionState.test.tsx b/src/features/agents/sessionState.test.tsx index aa7bb42d7..0e21c2270 100644 --- a/src/features/agents/sessionState.test.tsx +++ b/src/features/agents/sessionState.test.tsx @@ -22,6 +22,7 @@ import { useChangesOptions } from "./changesOptions"; import { taskActions } from "./taskActions"; import { replyActions } from "./replyActions"; import { focusedSession } from "./sessionFocus"; +import { PLAYFUL_MIN_MS, PLAYFUL_WORD_MS, PLAYFUL_WORDS } from "./workingStatus"; import styles from "./Session.module.css"; import chipStyles from "./ReferenceChip.module.css"; import { caretOf, textOf, typeIn } from "./composerTesting"; @@ -484,11 +485,130 @@ describe("turn folding", () => { // The turn isn't over: its latest message is no final reply yet. expect(stream().querySelector(`.${styles.agentMessage} > .${styles.messageFooter}`)).toBeNull(); // What the agent is doing ends the conversation, below its latest output. - const working = within(stream()).getByText("Working…").closest(`.${styles.working}`); + const working = stream().querySelector(`.${styles.working}`); + expect(working).toHaveRole("status"); expect(stream().lastElementChild).toBe(working); }); }); +describe("working status", () => { + const running = (entries: AgentEntry[]) => { + backend.entries.set("A", [ + { type: "user", text: "Question", attachments: [], steered: false, sentMs: 1000, doneMs: null }, + ...entries, + ]); + useAgents.setState({ + entries: new Map(backend.entries), + tasks: new Map(useAgents.getState().tasks).set("A", { + ...useAgents.getState().tasks.get("A")!, + status: "running", + }), + }); + }; + const playful = (status: HTMLElement) => status.querySelector("[aria-hidden]")?.textContent ?? null; + const playfulOn = (agents: object = {}) => + useProject.setState({ settings: { agents: { playfulStatus: true, ...agents } } as never }); + + it("says plainly what the agent does by default", async () => { + vi.useFakeTimers(); + running([tool("one", { status: "running" })]); + render(); + await act(async () => {}); + await act(() => vi.advanceTimersByTimeAsync(PLAYFUL_WORD_MS * 2)); + const status = stream().querySelector(`.${styles.working}`)!; + expect(playful(status)).toBeNull(); + expect(status).toHaveTextContent("Reading…"); + }); + + it("is playful from the start, holds each word while the work goes on, and turns to the new work's words", async () => { + vi.useFakeTimers(); + playfulOn(); + running([tool("one", { status: "running" })]); + render(); + await act(async () => {}); + const status = stream().querySelector(`.${styles.working}`)!; + const word = playful(status); + expect(PLAYFUL_WORDS.reading).toContain(word); + // Screen readers still hear the fact. + expect(status.querySelector(`.${styles.srOnly}`)).toHaveTextContent("Reading…"); + + // More of the same work keeps the word its full time. + running([tool("one", { status: "running" }), tool("two", { status: "running" })]); + await act(() => vi.advanceTimersByTimeAsync(PLAYFUL_WORD_MS - 1000)); + expect(playful(status)).toBe(word); + await act(() => vi.advanceTimersByTimeAsync(1000)); + const second = playful(status); + expect(PLAYFUL_WORDS.reading.filter((w) => w !== word)).toContain(second); + + // New work leaves the word a moment, then says the new work playfully too. + running([tool("one", { status: "running" }), { type: "agent", text: "Found it" }]); + await act(() => vi.advanceTimersByTimeAsync(1000)); + expect(playful(status)).toBe(second); + await act(() => vi.advanceTimersByTimeAsync(PLAYFUL_MIN_MS - 1000)); + expect(PLAYFUL_WORDS.writing).toContain(playful(status)); + expect(status.querySelector(`.${styles.srOnly}`)).toHaveTextContent("Writing…"); + }); + + it("with a quiet time, is factual until the agent reports nothing new for it, and again on progress", async () => { + vi.useFakeTimers(); + playfulOn({ playfulAfterSeconds: 10 }); + running([tool("one", { status: "running" })]); + render(); + await act(async () => {}); + const status = stream().querySelector(`.${styles.working}`)!; + expect(status).toHaveTextContent("Reading…"); + expect(playful(status)).toBeNull(); + + await act(() => vi.advanceTimersByTimeAsync(9000)); + expect(playful(status)).toBeNull(); + await act(() => vi.advanceTimersByTimeAsync(1000)); + const word = playful(status); + expect(PLAYFUL_WORDS.reading).toContain(word); + + // Progress right after a word appeared leaves it a moment before the fact returns. + running([tool("one", { status: "running" }), { type: "agent", text: "Found it" }]); + await act(() => vi.advanceTimersByTimeAsync(1000)); + expect(playful(status)).toBe(word); + await act(() => vi.advanceTimersByTimeAsync(PLAYFUL_MIN_MS - 1000)); + expect(playful(status)).toBeNull(); + expect(status).toHaveTextContent("Writing…"); + }); + + it("keeps each word its full time however soon the status turns playful", async () => { + vi.useFakeTimers(); + playfulOn({ playfulAfterSeconds: 1 }); + running([tool("one", { status: "running" })]); + render(); + await act(async () => {}); + const status = stream().querySelector(`.${styles.working}`)!; + await act(() => vi.advanceTimersByTimeAsync(1000)); + const word = playful(status); + expect(PLAYFUL_WORDS.reading).toContain(word); + await act(() => vi.advanceTimersByTimeAsync(PLAYFUL_WORD_MS - 1000)); + expect(playful(status)).toBe(word); + await act(() => vi.advanceTimersByTimeAsync(1000)); + expect(PLAYFUL_WORDS.reading.filter((w) => w !== word)).toContain(playful(status)); + }); + + it("shows the user's own words of the activity, and none where they left the list empty", async () => { + vi.useFakeTimers(); + playfulOn({ playfulWords: { reading: ["Squinting really hard…"], working: [] } }); + running([]); + render(); + await act(async () => {}); + const status = stream().querySelector(`.${styles.working}`)!; + // Nothing reported yet is `working`, whose list the user emptied. + expect(playful(status)).toBeNull(); + expect(status).toHaveTextContent("Working…"); + + running([tool("one", { status: "running" })]); + await act(() => vi.advanceTimersByTimeAsync(1000)); + expect(playful(status)).toBe("Squinting really hard…"); + await act(() => vi.advanceTimersByTimeAsync(PLAYFUL_WORD_MS)); + expect(playful(status)).toBe("Squinting really hard…"); + }); +}); + describe("opened runs", () => { it("stay open when the finished turn folds them away and is opened again", async () => { const asked = { diff --git a/src/features/agents/workingStatus.ts b/src/features/agents/workingStatus.ts new file mode 100644 index 000000000..d7963b01c --- /dev/null +++ b/src/features/agents/workingStatus.ts @@ -0,0 +1,158 @@ +/** + * The label of the row under a conversation while the agent works: what the turn's latest + * output says it is doing, and playful words while it reports nothing new (or nothing yet). + */ +import type { AgentEntry } from "@/bindings"; +import { subagentWorking } from "./model"; + +/** How long one playful word stays while the agent still reports nothing new. */ +export const PLAYFUL_WORD_MS = 8_000; +/** How long a playful word stays at least, even when the agent reports something new meanwhile. */ +export const PLAYFUL_MIN_MS = 3_000; + +/** What the agent can be doing, as the status tells it; `working` covers the rest. */ +export const ACTIVITIES = [ + "working", + "thinking", + "writing", + "reading", + "editing", + "deleting", + "moving", + "searching", + "running", + "fetching", + "subagent", +] as const; +export type Activity = (typeof ACTIVITIES)[number]; + +/** The factual status of each activity, also what screen readers hear while it is playful. */ +export const ACTIVITY_STATUS: Record = { + working: "Working…", + thinking: "Thinking…", + writing: "Writing…", + reading: "Reading…", + editing: "Editing…", + deleting: "Deleting…", + moving: "Moving files…", + searching: "Searching…", + running: "Running a command…", + fetching: "Fetching…", + subagent: "Running a subagent…", +}; + +/** The built-in playful words of each activity, until the user writes their own. */ +export const PLAYFUL_WORDS: Record = { + working: [ + "Untangling imports…", + "Explaining it to the rubber duck…", + "Herding semicolons…", + "Rebasing onto reality…", + "Measuring twice…", + "Sharpening the pencils…", + "Invalidating a cache…", + ], + thinking: [ + "Refactoring a hunch…", + "Garbage-collecting thoughts…", + "Compiling a plan…", + "Caching an insight…", + "Bisecting the problem…", + "Naming things…", + ], + writing: [ + "Counting brackets…", + "Settling tabs versus spaces…", + "Choosing words carefully…", + "Polishing the prose…", + "Drafting, redrafting…", + ], + reading: [ + "Reading the fine manual…", + "Following the breadcrumbs…", + "Walking the call stack…", + "Reading between the lines…", + "Skimming the source…", + ], + editing: [ + "Squinting at the diff…", + "Negotiating with the borrow checker…", + "Asking the linter nicely…", + "Nudging a semicolon…", + "Moving code around gently…", + ], + deleting: ["Tidying up…", "Taking out the trash…", "Pruning dead code…", "Saying goodbye…"], + moving: ["Rearranging the furniture…", "Packing boxes…", "Finding a better home…"], + searching: ["Grepping the void…", "Chasing a null pointer…", "Looking under the couch…", "Searching high and low…"], + running: [ + "Warming up the compiler…", + "Pressing Enter with confidence…", + "Watching the logs scroll…", + "Waiting on the shell…", + ], + fetching: ["Waiting on the network…", "Downloading the internet…", "Following links…"], + subagent: ["Delegating…", "Consulting a colleague…", "Calling in reinforcements…", "Holding a quick stand-up…"], +}; + +const TOOL_ACTIVITY: Record = { + read: "reading", + edit: "editing", + delete: "deleting", + move: "moving", + search: "searching", + execute: "running", + fetch: "fetching", + think: "thinking", +}; + +/** What the turn's latest entry says the agent is doing; null before it reports anything. */ +export function activityOf(turn: readonly AgentEntry[]): Activity | null { + const last = turn.at(-1); + if (!last) return null; + switch (last.type) { + case "thought": + return "thinking"; + case "agent": + return "writing"; + case "tool": + return last.status === "pending" || last.status === "running" + ? (TOOL_ACTIVITY[last.kind] ?? "working") + : "working"; + case "subagent": + return subagentWorking(last.status) ? "subagent" : "working"; + default: + return "working"; + } +} + +/** Changes whenever the agent reports something new in the turn: an entry, more text, a tool's progress. */ +export function progressKey(turn: readonly AgentEntry[]): string { + const last = turn.at(-1); + const detail = + last?.type === "agent" || last?.type === "thought" + ? last.text.length + : last?.type === "tool" + ? `${last.status}:${last.output?.length ?? 0}` + : last?.type === "subagent" + ? last.status + : ""; + return `${turn.length}:${last?.type ?? ""}:${detail}`; +} + +/** + * Which of `count` playful words is the `n`th to show in the turn that started at `seed`. Each turn + * goes through every word in an order of its own. + */ +export function playfulIndex(count: number, seed: number, n: number): number { + const order = Array.from({ length: count }, (_, i) => i); + let state = seed >>> 0; + for (let i = order.length - 1; i > 0; i--) { + // mulberry32 + state = (state + 0x6d2b79f5) >>> 0; + let r = Math.imul(state ^ (state >>> 15), state | 1); + r ^= r + Math.imul(r ^ (r >>> 7), r | 61); + const j = ((r ^ (r >>> 14)) >>> 0) % (i + 1); + [order[i], order[j]] = [order[j]!, order[i]!]; + } + return order[n % count]!; +} diff --git a/src/features/agents/workingStatusPage.test.tsx b/src/features/agents/workingStatusPage.test.tsx new file mode 100644 index 000000000..0144b5144 --- /dev/null +++ b/src/features/agents/workingStatusPage.test.tsx @@ -0,0 +1,83 @@ +import { afterEach, beforeEach, describe, expect, it } from "vitest"; +import { fireEvent, render, screen, within } from "@testing-library/react"; +import { SettingsFormContext } from "@/workbench/contributions"; +import { useSettingsFormFor } from "@/features/settings/components/context"; +import { closeSettings, openSettings, stagedValue, useSettingsDialog } from "@/features/settings/model/staging"; +import { WORKING_STATUS_PAGE } from "./model"; +import { WorkingStatusPage as Page } from "./WorkingStatusPage"; +import { PLAYFUL_WORDS } from "./workingStatus"; + +function WorkingStatusPage() { + const form = useSettingsFormFor(WORKING_STATUS_PAGE, "global"); + return ( + + + + ); +} + +const staged = () => stagedValue(useSettingsDialog.getState(), "global", "agents.playfulWords"); +const words = () => + within(screen.getByRole("list", { name: "Playful words" })) + .queryAllByRole("listitem") + .map((item) => item.textContent); +/** The page with playful words turned on, so its word controls are enabled. */ +function renderOn() { + render(); + fireEvent.click(screen.getByRole("checkbox", { name: "Playful words while the agent works" })); +} + +describe("Working Status settings", () => { + beforeEach(() => openSettings(WORKING_STATUS_PAGE)); + afterEach(() => closeSettings()); + + it("is off by default, and turning it on enables the words", () => { + render(); + const toggle = screen.getByRole("checkbox", { name: "Playful words while the agent works" }); + expect(toggle).not.toBeChecked(); + expect(screen.getByRole("textbox", { name: "New playful word" })).toBeDisabled(); + fireEvent.click(toggle); + expect(stagedValue(useSettingsDialog.getState(), "global", "agents.playfulStatus")).toBe(true); + expect(screen.getByRole("textbox", { name: "New playful word" })).toBeEnabled(); + }); + + it("turns the built-in words into the user's own on the first edit, and restores them", () => { + renderOn(); + const builtIn = [...PLAYFUL_WORDS.working]; + expect(words()).toEqual(builtIn); + + fireEvent.click(screen.getByRole("button", { name: `Remove ${builtIn[0]}` })); + const input = screen.getByRole("textbox", { name: "New playful word" }); + fireEvent.change(input, { target: { value: " Reticulating splines… " } }); + // Enter adds the word and is not left to press the Settings dialog's OK. + expect(fireEvent.keyDown(input, { key: "Enter" })).toBe(false); + const own = [...builtIn.slice(1), "Reticulating splines…"]; + expect(words()).toEqual(own); + expect(staged()).toEqual({ working: own }); + + fireEvent.click(screen.getByRole("button", { name: "Restore Built-in Words" })); + expect(staged()).toEqual({}); + expect(words()).toEqual(builtIn); + }); + + it("keeps an emptied list, which leaves the status factual", () => { + renderOn(); + for (const word of PLAYFUL_WORDS.working) fireEvent.click(screen.getByRole("button", { name: `Remove ${word}` })); + expect(staged()).toEqual({ working: [] }); + expect(screen.getByText("No playful words: the status stays factual")).toBeInTheDocument(); + }); + + it("saves the quiet time while the text is a valid number, and drops invalid text on blur", () => { + renderOn(); + const after = () => stagedValue(useSettingsDialog.getState(), "global", "agents.playfulAfterSeconds"); + const seconds = screen.getByRole("textbox", { name: "Start after the agent reports nothing new for" }); + expect(seconds).toHaveValue("0"); + fireEvent.change(seconds, { target: { value: "25" } }); + expect(after()).toBe(25); + fireEvent.change(seconds, { target: { value: "601" } }); + expect(seconds).toHaveAttribute("aria-invalid", "true"); + expect(after()).toBe(25); + fireEvent.blur(seconds); + expect(seconds).toHaveValue("25"); + }); +}); diff --git a/src/features/settings/__tests__/agents.test.ts b/src/features/settings/__tests__/agents.test.ts index a7de5649c..1ca1cf58a 100644 --- a/src/features/settings/__tests__/agents.test.ts +++ b/src/features/settings/__tests__/agents.test.ts @@ -11,6 +11,9 @@ describe("agent chat settings", () => { foldTurns: true, smoothText: true, fitWindowWidth: false, + playfulStatus: false, + playfulAfterSeconds: 0, + playfulWords: {}, thinking: "auto", toolCalls: "grouped", expandToolOutput: false, @@ -52,4 +55,20 @@ describe("agent chat settings", () => { }); expect(validateSettings({ agents: { newTaskApprovals: "never" } }).agents.newTaskApprovals).toBe("bypass"); }); + + it("keeps the user's playful words by activity, an emptied list included", () => { + const stored = validateSettings({ + agents: { playfulWords: { reading: ["Squinting…", " ", 3], working: [], editing: "nope" } }, + }).agents; + expect(stored.playfulWords).toEqual({ reading: ["Squinting…"], working: [] }); + }); + + it("keeps the playful quiet time in whole seconds within its range", () => { + const after = (v: unknown) => validateSettings({ agents: { playfulAfterSeconds: v } }).agents.playfulAfterSeconds; + expect(after(0)).toBe(0); + expect(after(2.6)).toBe(3); + expect(after(-5)).toBe(0); + expect(after(100_000)).toBe(600); + expect(after("soon")).toBe(0); + }); }); diff --git a/src/features/settings/model/schema.ts b/src/features/settings/model/schema.ts index 1c8a119a3..8c2619e65 100644 --- a/src/features/settings/model/schema.ts +++ b/src/features/settings/model/schema.ts @@ -39,6 +39,7 @@ import { type NotificationsValid, } from "./behaviorSchema"; import { isThemeChoiceId, type ThemeChoiceId } from "@/platform/themes"; +import { PLAYFUL_AFTER_LIMITS } from "@/platform/agentStatus"; /** Agents › IDE MCP Server › Port: its default (`ide-core::settings::DEFAULT_MCP_PORT`) and range. */ export const DEFAULT_MCP_PORT = 26371; @@ -213,6 +214,9 @@ export const DEFAULT_SETTINGS: ValidSettings = { foldTurns: true, smoothText: true, fitWindowWidth: false, + playfulStatus: false, + playfulAfterSeconds: 0, + playfulWords: {}, thinking: "auto", toolCalls: "grouped", expandToolOutput: false, @@ -259,6 +263,15 @@ function agentDefaults(v: unknown): Record> { return Object.fromEntries(Object.entries(obj(v)).map(([agent, options]) => [agent, stringMap(options)])); } +/** Activity → the user's playful words; a list, even an empty one, stands for that activity. */ +function playfulWords(v: unknown): Record { + return Object.fromEntries( + Object.entries(obj(v)) + .filter(([, words]) => Array.isArray(words)) + .map(([activity, words]) => [activity, stringList(words)]), + ); +} + function agentMcpServers(v: unknown): Required["mcpServers"] { const out: Required["mcpServers"] = {}; for (const [name, raw] of Object.entries(obj(v))) { @@ -393,6 +406,9 @@ export function validateSettings(raw: Settings | unknown): ValidSettings { foldTurns: bool(agents.foldTurns, d.agents.foldTurns), smoothText: bool(agents.smoothText, d.agents.smoothText), fitWindowWidth: bool(agents.fitWindowWidth, d.agents.fitWindowWidth), + playfulStatus: bool(agents.playfulStatus, d.agents.playfulStatus), + playfulAfterSeconds: num(agents.playfulAfterSeconds, d.agents.playfulAfterSeconds, PLAYFUL_AFTER_LIMITS, true), + playfulWords: playfulWords(agents.playfulWords), thinking: oneOf(agents.thinking, ["auto", "expanded", "collapsed"] as const, d.agents.thinking), toolCalls: oneOf(agents.toolCalls, ["grouped", "each"] as const, d.agents.toolCalls), expandToolOutput: bool(agents.expandToolOutput, d.agents.expandToolOutput), diff --git a/src/platform/agentStatus.ts b/src/platform/agentStatus.ts new file mode 100644 index 000000000..2ee4865ce --- /dev/null +++ b/src/platform/agentStatus.ts @@ -0,0 +1,2 @@ +/** Settings › Agents › Working Status: seconds the agent may report nothing new before playful words show. */ +export const PLAYFUL_AFTER_LIMITS = { min: 0, max: 600 } as const; diff --git a/src/platform/locales/text/en.json b/src/platform/locales/text/en.json index cab6d57b7..3cda5aa89 100644 --- a/src/platform/locales/text/en.json +++ b/src/platform/locales/text/en.json @@ -1793,5 +1793,74 @@ "Show Changes": "Show Changes", "Previous Failed Test": "Previous Failed Test", "Next Failed Test": "Next Failed Test", - "Run '{name}' with Fuzzing": "Run '{name}' with Fuzzing" + "Run '{name}' with Fuzzing": "Run '{name}' with Fuzzing", + "Untangling imports…": "Untangling imports…", + "Counting brackets…": "Counting brackets…", + "Herding semicolons…": "Herding semicolons…", + "Explaining it to the rubber duck…": "Explaining it to the rubber duck…", + "Negotiating with the borrow checker…": "Negotiating with the borrow checker…", + "Chasing a null pointer…": "Chasing a null pointer…", + "Bisecting the problem…": "Bisecting the problem…", + "Reading the fine manual…": "Reading the fine manual…", + "Refactoring a hunch…": "Refactoring a hunch…", + "Grepping the void…": "Grepping the void…", + "Garbage-collecting thoughts…": "Garbage-collecting thoughts…", + "Rebasing onto reality…": "Rebasing onto reality…", + "Compiling a plan…": "Compiling a plan…", + "Walking the call stack…": "Walking the call stack…", + "Warming up the compiler…": "Warming up the compiler…", + "Settling tabs versus spaces…": "Settling tabs versus spaces…", + "Caching an insight…": "Caching an insight…", + "Following the breadcrumbs…": "Following the breadcrumbs…", + "Squinting at the diff…": "Squinting at the diff…", + "Asking the linter nicely…": "Asking the linter nicely…", + "Measuring twice…": "Measuring twice…", + "Sharpening the pencils…": "Sharpening the pencils…", + "Naming things…": "Naming things…", + "Invalidating a cache…": "Invalidating a cache…", + "Reading…": "Reading…", + "Editing…": "Editing…", + "Deleting…": "Deleting…", + "Moving files…": "Moving files…", + "Running a command…": "Running a command…", + "Fetching…": "Fetching…", + "Thinking…": "Thinking…", + "Writing…": "Writing…", + "Running a subagent…": "Running a subagent…", + "Playful words while the agent works": "Playful words while the agent works", + "Choosing words carefully…": "Choosing words carefully…", + "Polishing the prose…": "Polishing the prose…", + "Drafting, redrafting…": "Drafting, redrafting…", + "Reading between the lines…": "Reading between the lines…", + "Skimming the source…": "Skimming the source…", + "Nudging a semicolon…": "Nudging a semicolon…", + "Moving code around gently…": "Moving code around gently…", + "Tidying up…": "Tidying up…", + "Taking out the trash…": "Taking out the trash…", + "Pruning dead code…": "Pruning dead code…", + "Saying goodbye…": "Saying goodbye…", + "Rearranging the furniture…": "Rearranging the furniture…", + "Packing boxes…": "Packing boxes…", + "Finding a better home…": "Finding a better home…", + "Looking under the couch…": "Looking under the couch…", + "Searching high and low…": "Searching high and low…", + "Pressing Enter with confidence…": "Pressing Enter with confidence…", + "Watching the logs scroll…": "Watching the logs scroll…", + "Waiting on the shell…": "Waiting on the shell…", + "Waiting on the network…": "Waiting on the network…", + "Downloading the internet…": "Downloading the internet…", + "Following links…": "Following links…", + "Delegating…": "Delegating…", + "Consulting a colleague…": "Consulting a colleague…", + "Calling in reinforcements…": "Calling in reinforcements…", + "Holding a quick stand-up…": "Holding a quick stand-up…", + "Working Status": "Working Status", + "While the agent works, the line under the conversation says what it is doing. With playful words on, words for what it does take turns there instead, from the start or once it reports nothing new for a while; screen readers still hear the plain status.": "While the agent works, the line under the conversation says what it is doing. With playful words on, words for what it does take turns there instead, from the start or once it reports nothing new for a while; screen readers still hear the plain status.", + "Start after the agent reports nothing new for": "Start after the agent reports nothing new for", + "While the status says": "While the status says", + "Playful words": "Playful words", + "No playful words: the status stays factual": "No playful words: the status stays factual", + "e.g. Reticulating splines…": "e.g. Reticulating splines…", + "New playful word": "New playful word", + "Restore Built-in Words": "Restore Built-in Words" } diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json index fa7976943..811a18b90 100644 --- a/src/platform/locales/text/zh.json +++ b/src/platform/locales/text/zh.json @@ -8194,5 +8194,74 @@ "Show Changes": "显示更改", "Previous Failed Test": "上一个失败的测试", "Next Failed Test": "下一个失败的测试", - "Run '{name}' with Fuzzing": "使用模糊测试运行 '{name}'" + "Run '{name}' with Fuzzing": "使用模糊测试运行 '{name}'", + "Untangling imports…": "正在理顺 import…", + "Counting brackets…": "正在数括号…", + "Herding semicolons…": "正在清点分号…", + "Explaining it to the rubber duck…": "正在讲给小黄鸭听…", + "Negotiating with the borrow checker…": "正在和借用检查器讲道理…", + "Chasing a null pointer…": "正在追捕空指针…", + "Bisecting the problem…": "正在二分排查…", + "Reading the fine manual…": "正在认真读文档…", + "Refactoring a hunch…": "正在重构一个直觉…", + "Grepping the void…": "正在 grep 虚空…", + "Garbage-collecting thoughts…": "正在回收思绪…", + "Rebasing onto reality…": "正在变基到现实…", + "Compiling a plan…": "正在编译计划…", + "Walking the call stack…": "正在顺着调用栈往上爬…", + "Warming up the compiler…": "正在预热编译器…", + "Settling tabs versus spaces…": "正在调停 Tab 与空格之争…", + "Caching an insight…": "正在缓存灵感…", + "Following the breadcrumbs…": "正在顺藤摸瓜…", + "Squinting at the diff…": "正在眯眼看 diff…", + "Asking the linter nicely…": "正在好言相劝 linter…", + "Measuring twice…": "正在三思而后行…", + "Sharpening the pencils…": "正在削铅笔…", + "Naming things…": "正在给变量起名…", + "Invalidating a cache…": "正在让缓存失效…", + "Choosing words carefully…": "正在斟酌用词…", + "Polishing the prose…": "正在润色文字…", + "Drafting, redrafting…": "正在打草稿,再打草稿…", + "Reading between the lines…": "正在读出言外之意…", + "Skimming the source…": "正在速读源码…", + "Nudging a semicolon…": "正在挪动一个分号…", + "Moving code around gently…": "正在轻轻挪动代码…", + "Tidying up…": "正在收拾…", + "Taking out the trash…": "正在倒垃圾…", + "Pruning dead code…": "正在修剪死代码…", + "Saying goodbye…": "正在挥手告别…", + "Rearranging the furniture…": "正在重新摆放家具…", + "Packing boxes…": "正在打包纸箱…", + "Finding a better home…": "正在找个更好的家…", + "Looking under the couch…": "正在沙发底下找…", + "Searching high and low…": "正在上天入地地找…", + "Pressing Enter with confidence…": "正在自信地按下回车…", + "Watching the logs scroll…": "正在看日志滚动…", + "Waiting on the shell…": "正在等 shell 回话…", + "Waiting on the network…": "正在等网络…", + "Downloading the internet…": "正在下载整个互联网…", + "Following links…": "正在顺着链接走…", + "Delegating…": "正在分派任务…", + "Consulting a colleague…": "正在请教同事…", + "Calling in reinforcements…": "正在呼叫增援…", + "Holding a quick stand-up…": "正在开个简短站会…", + "Reading…": "正在读取…", + "Editing…": "正在编辑…", + "Deleting…": "正在删除…", + "Moving files…": "正在移动文件…", + "Running a command…": "正在运行命令…", + "Fetching…": "正在获取…", + "Thinking…": "正在思考…", + "Writing…": "正在输出…", + "Running a subagent…": "子 agent 正在运行…", + "Playful words while the agent works": "agent 工作时显示趣味文字", + "Working Status": "工作状态", + "While the agent works, the line under the conversation says what it is doing. With playful words on, words for what it does take turns there instead, from the start or once it reports nothing new for a while; screen readers still hear the plain status.": "agent 工作时,对话下方的状态行显示它正在做什么。开启趣味文字后,这里会改为轮换显示与当前工作相关的趣味文字,可以从一开始就显示,也可以在它一段时间没有新进展后才显示;屏幕阅读器读出的仍是实际状态。", + "Start after the agent reports nothing new for": "在 agent 无新进展超过", + "While the status says": "当状态为", + "Playful words": "趣味文字", + "No playful words: the status stays factual": "没有趣味文字:状态只显示实际进展", + "e.g. Reticulating splines…": "例如:正在网格化样条曲线…", + "New playful word": "新的趣味文字", + "Restore Built-in Words": "恢复内置文字" }