pi-web-ui 0.68.2 → 0.69.0

package/dist/server/edit-soft-tool.js

@@ -22,17 +22,22 @@ import { homedir } from "node:os";
 import { isAbsolute, join, resolve as nodeResolve } from "node:path";
 import { Type } from "typebox";
 import { defineTool, generateDiffString, generateUnifiedPatch, withFileMutationQueue, } from "@earendil-works/pi-coding-agent";
+import { bilingual, pick } from "./i18n.js";
 export const SOFT_EDIT_TOOL_NAME = "edit_soft";
 const replaceEditSchema = Type.Object({
     oldText: Type.String({
-        description: "要替换的文本。宽松匹配：每个非空行的内容（去掉首尾空白）需与文件中对应行一致；行首缩进（空格/制表符）的差异会被忽略。建议按整行/整块提供。",
+        description: bilingual("Text to replace. Loose matching: the content of each non-empty line (trimmed of leading/trailing whitespace) must match the corresponding file lines; leading-indentation (spaces/tabs) differences are ignored. Prefer whole lines/blocks.", "要替换的文本。宽松匹配：每个非空行的内容（去掉首尾空白）需与文件中对应行一致；行首缩进（空格/制表符）的差异会被忽略。建议按整行/整块提供。"),
+    }),
+    newText: Type.String({
+        description: bilingual("Replacement text (written verbatim; the indentation you provide is final).", "替换后的文本（原样写入，缩进即最终缩进）。"),
     }),
-    newText: Type.String({ description: "替换后的文本（原样写入，缩进即最终缩进）。" }),
 }, {});
 const editSoftSchema = Type.Object({
-    path: Type.String({ description: "要编辑的文件路径（相对或绝对）" }),
+    path: Type.String({
+        description: bilingual("Path of the file to edit (relative or absolute).", "要编辑的文件路径（相对或绝对）"),
+    }),
     edits: Type.Array(replaceEditSchema, {
-        description: "一个或多个定向替换。每个 edit 相对原文件匹配（非增量）；不要包含重叠/嵌套的 edit；同一块或相邻行请合并成一个 edit。",
+        description: bilingual("One or more targeted replacements. Each edit matches against the original file (not incrementally); do not include overlapping/nested edits; merge edits touching the same block or nearby lines into one.", "一个或多个定向替换。每个 edit 相对原文件匹配（非增量）；不要包含重叠/嵌套的 edit；同一块或相邻行请合并成一个 edit。"),
     }),
 }, {});
 function isSingleEditInput(value) {
@@ -145,9 +150,9 @@ class SoftEditMatchError extends Error {
  * 命中一个 edit：先精确，后行核心宽松。返回原文件字符区间 + 待写入文本。
  * spans 全部相对 LF 归一化后的原文件正文。
  */
-function locateReplacement(normalizedContent, oldTextLF, newTextLF, path, editIndex) {
+function locateReplacement(normalizedContent, oldTextLF, newTextLF, path, editIndex, lang = "en") {
     if (oldTextLF.length === 0) {
-        throw new SoftEditMatchError(`edits[${editIndex}].oldText must not be empty in ${path}.`);
+        throw new SoftEditMatchError(pick(lang, `edits[${editIndex}].oldText 在 ${path} 中不能为空。`, `edits[${editIndex}].oldText must not be empty in ${path}.`, "editsoft.oldtext.empty", { editIndex, path }));
     }
     // 1) 精确子串匹配（等价普通 edit，支持片段）
     const exactIdx = normalizedContent.indexOf(oldTextLF);
@@ -155,14 +160,14 @@ function locateReplacement(normalizedContent, oldTextLF, newTextLF, path, editIn
         // 唯一性：精确匹配出现多次 → 报错（模型应提供更多上下文）
         const occurrences = normalizedContent.split(oldTextLF).length - 1;
         if (occurrences > 1) {
-            throw new SoftEditMatchError(`Found ${occurrences} occurrences of edits[${editIndex}].oldText in ${path}. Each oldText must be unique. Please provide more context to make it unique.`);
+            throw new SoftEditMatchError(pick(lang, `在 ${path} 中找到 ${occurrences} 处 edits[${editIndex}].oldText。每个 oldText 必须唯一，请提供更多上下文。`, `Found ${occurrences} occurrences of edits[${editIndex}].oldText in ${path}. Each oldText must be unique. Please provide more context to make it unique.`, "editsoft.exact.not.unique", { path, occurrences, editIndex }));
         }
         return { start: exactIdx, end: exactIdx + oldTextLF.length, insertText: newTextLF };
     }
     // 2) 行核心宽松匹配：逐行 trim 后序列一致（忽略缩进差异）
     const cores = oldTextCores(oldTextLF);
     if (cores.length === 0) {
-        throw new SoftEditMatchError(`edits[${editIndex}].oldText is effectively empty in ${path}.`);
+        throw new SoftEditMatchError(pick(lang, `edits[${editIndex}].oldText 在 ${path} 中实际为空。`, `edits[${editIndex}].oldText is effectively empty in ${path}.`, "editsoft.oldtext.blank", { editIndex, path }));
     }
     const units = splitLineUnits(normalizedContent);
     const k = cores.length;
@@ -179,10 +184,10 @@ function locateReplacement(normalizedContent, oldTextLF, newTextLF, path, editIn
             starts.push(i);
     }
     if (starts.length === 0) {
-        throw new SoftEditMatchError(`Could not find the text (exact or indentation-insensitive) in ${path}. The oldText must match the file's line content; leading-whitespace differences are ignored, but the actual content must be identical.`);
+        throw new SoftEditMatchError(pick(lang, `在 ${path} 中找不到该文本（精确或忽略缩进均未命中）。oldText 必须与文件的行内容一致；行首空白差异会被忽略，但实际内容必须完全相同。`, `Could not find the text (exact or indentation-insensitive) in ${path}. The oldText must match the file's line content; leading-whitespace differences are ignored, but the actual content must be identical.`, "editsoft.match.not.found", { path }));
     }
     if (starts.length > 1) {
-        throw new SoftEditMatchError(`Found ${starts.length} indentation-insensitive occurrences of edits[${editIndex}].oldText in ${path}. The text must be unique. Please provide more context to make it unique.`);
+        throw new SoftEditMatchError(pick(lang, `在 ${path} 中找到 ${starts.length} 处忽略缩进的 edits[${editIndex}].oldText。文本必须唯一，请提供更多上下文。`, `Found ${starts.length} indentation-insensitive occurrences of edits[${editIndex}].oldText in ${path}. The text must be unique. Please provide more context to make it unique.`, "editsoft.match.not.unique", { path, "starts.length": starts.length, editIndex }));
     }
     const li = starts[0];
     const ri = li + k;
@@ -196,18 +201,18 @@ function locateReplacement(normalizedContent, oldTextLF, newTextLF, path, editIn
     return { start: spanStart, end: spanEnd, insertText };
 }
 /** 对 LF 归一化内容应用一组 edit（含重叠检测），返回 {base,next}。 */
-export function applySoftEdits(normalizedContent, edits, path) {
+export function applySoftEdits(normalizedContent, edits, path, lang = "en") {
     const replacements = [];
     for (let i = 0; i < edits.length; i++) {
         const oldTextLF = normalizeToLF(edits[i].oldText);
         const newTextLF = normalizeToLF(edits[i].newText);
-        replacements.push(locateReplacement(normalizedContent, oldTextLF, newTextLF, path, i));
+        replacements.push(locateReplacement(normalizedContent, oldTextLF, newTextLF, path, i, lang));
     }
     // 重叠检测
     const sorted = [...replacements].sort((a, b) => a.start - b.start);
     for (let i = 1; i < sorted.length; i++) {
         if (sorted[i - 1].end > sorted[i].start) {
-            throw new SoftEditMatchError(`edits overlap in ${path}. Merge them into one edit or target disjoint regions.`);
+            throw new SoftEditMatchError(pick(lang, `在 ${path} 中的 edits 重叠。请合并为一个 edit 或定位到不相交的区域。`, `edits overlap in ${path}. Merge them into one edit or target disjoint regions.`, "editsoft.edits.overlap", { path }));
         }
     }
     // 逆序应用，保持左侧偏移稳定
@@ -217,39 +222,41 @@ export function applySoftEdits(normalizedContent, edits, path) {
         result = result.slice(0, r.start) + r.insertText + result.slice(r.end);
     }
     if (result === normalizedContent) {
-        throw new SoftEditMatchError(`No changes made to ${path}. The replacement produced identical content.`);
+        throw new SoftEditMatchError(pick(lang, `${path} 没有变化。替换产生了完全相同的内容。`, `No changes made to ${path}. The replacement produced identical content.`, "editsoft.result.identical", { path }));
     }
     return { baseContent: normalizedContent, newContent: result };
 }
 /**
  * 生成 edit_soft 工具定义。与内置 edit 同结构执行体，但用宽松缩进匹配 + 原样 newText。
  * cwd 仅供创建时固定；执行时优先 ctx.cwd（会话工作区）。
+ * getLang 为可选的服务端语言取值器（每次调用时读取，默认英文，issue #91）。
  */
-export function makeEditSoftTool(fallbackCwd) {
+export function makeEditSoftTool(fallbackCwd, getLang) {
     return defineTool({
         name: SOFT_EDIT_TOOL_NAME,
         label: "Edit (indentation-insensitive)",
-        description: "Edit a single file using text replacement that is tolerant of indentation. Every edits[].oldText is matched to the file by line content: leading whitespace (spaces/tabs) differences between your oldText and the file are ignored, so an edit does not fail just because the indentation differs. Use this when the built-in edit tool rejects your oldText due to a whitespace mismatch (common in JS/JSON/etc.). Prefer whole-line/whole-block oldText. newText is written exactly as provided.",
-        promptSnippet: "edit a file tolerating indentation differences (whitespace-insensitive match)",
+        description: bilingual("Edit a single file using text replacement that is tolerant of indentation. Every edits[].oldText is matched to the file by line content: leading whitespace (spaces/tabs) differences between your oldText and the file are ignored, so an edit does not fail just because the indentation differs. Use this when the built-in edit tool rejects your oldText due to a whitespace mismatch (common in JS/JSON/etc.). Prefer whole-line/whole-block oldText. newText is written exactly as provided.", "用对缩进不敏感的文本替换编辑单个文件。每个 edits[].oldText 按行内容与文件匹配：oldText 与文件之间的行首空白（空格/制表符）差异会被忽略，因此不会仅因缩进不同而失败。当内置 edit 工具因空白不匹配拒绝你的 oldText 时使用本工具（常见于 JS/JSON 等）。oldText 尽量按整行/整块提供。newText 按原样写入。"),
+        promptSnippet: bilingual("edit a file tolerating indentation differences (whitespace-insensitive match)", "编辑文件，容忍缩进差异（空白不敏感匹配）"),
         promptGuidelines: [
-            "Use edit_soft when edit fails because the oldText indentation/spacing differs from the file",
-            "Each edits[].oldText is matched to whole lines by trimmed content; leading whitespace is ignored",
-            "newText is written verbatim — the indentation you provide is the final indentation in the file",
-            "Keep edits[].oldText as small as possible while still being unique; merge nearby changes into one edit",
+            bilingual("Use edit_soft when edit fails because the oldText indentation/spacing differs from the file", "当 edit 因 oldText 缩进/空白与文件不一致而失败时，使用 edit_soft"),
+            bilingual("Each edits[].oldText is matched to whole lines by trimmed content; leading whitespace is ignored", "每个 edits[].oldText 按去首尾空白后的内容匹配到整行；行首空白会被忽略"),
+            bilingual("newText is written verbatim — the indentation you provide is the final indentation in the file", "newText 按原样写入——你提供的缩进就是文件中的最终缩进"),
+            bilingual("Keep edits[].oldText as small as possible while still being unique; merge nearby changes into one edit", "edits[].oldText 在保持唯一的前提下尽量小；相邻改动合并为一个 edit"),
         ],
         parameters: editSoftSchema,
         prepareArguments: prepareSoftEditArguments,
         async execute(_toolCallId, input, signal, _onUpdate, ctx) {
+            const lang = getLang?.() ?? "en";
             const { path, edits } = input;
             if (!Array.isArray(edits) || edits.length === 0) {
-                throw new Error("edit_soft input is invalid. edits must contain at least one replacement.");
+                throw new Error(pick(lang, "edit_soft 输入无效：edits 必须包含至少一个替换。", "edit_soft input is invalid. edits must contain at least one replacement.", "editsoft.input.no.edits"));
             }
             const cwd = typeof ctx?.cwd === "string" ? ctx.cwd : fallbackCwd;
             const absolutePath = resolveToCwd(path, cwd);
             return withFileMutationQueue(absolutePath, async () => {
                 const throwIfAborted = () => {
                     if (signal?.aborted)
-                        throw new Error("Operation aborted");
+                        throw new Error(pick(lang, "操作已中止", "Operation aborted", "editsoft.operation.aborted"));
                 };
                 throwIfAborted();
                 try {
@@ -258,7 +265,7 @@ export function makeEditSoftTool(fallbackCwd) {
                 catch (error) {
                     throwIfAborted();
                     const errorMessage = error instanceof Error && "code" in error ? `Error code: ${error.code}` : String(error);
-                    throw new Error(`Could not edit file: ${path}. ${errorMessage}.`);
+                    throw new Error(pick(lang, `无法编辑文件：${path}。${errorMessage}。`, `Could not edit file: ${path}. ${errorMessage}.`, "editsoft.file.access.failed", { path, errorMessage }));
                 }
                 throwIfAborted();
                 const buffer = await readFile(absolutePath);
@@ -267,7 +274,7 @@ export function makeEditSoftTool(fallbackCwd) {
                 const { bom, text: content } = splitBom(rawContent);
                 const originalEnding = detectLineEnding(content);
                 const normalizedContent = normalizeToLF(content);
-                const { baseContent, newContent } = applySoftEdits(normalizedContent, edits, path);
+                const { baseContent, newContent } = applySoftEdits(normalizedContent, edits, path, lang);
                 throwIfAborted();
                 const finalContent = bom + restoreLineEndings(newContent, originalEnding);
                 await writeFile(absolutePath, finalContent, "utf-8");
@@ -278,7 +285,7 @@ export function makeEditSoftTool(fallbackCwd) {
                     content: [
                         {
                             type: "text",
-                            text: `Successfully replaced ${edits.length} block(s) in ${path} (indentation-insensitive).`,
+                            text: pick(lang, `已在 ${path} 中替换 ${edits.length} 个块（忽略缩进匹配）。`, `Successfully replaced ${edits.length} block(s) in ${path} (indentation-insensitive).`, "editsoft.replace.done", { path, "edits.length": edits.length }),
                         },
                     ],
                     details: { diff: diffResult.diff, patch, firstChangedLine: diffResult.firstChangedLine },

package/dist/server/files-service.js

@@ -7,6 +7,7 @@
  */
 import { mkdirSync, statSync, writeFileSync, watch } from "node:fs";
 import { resolve, relative, sep } from "node:path";
+import { pick } from "./i18n.js";
 import { previewKind, looksLikeText, decodeText, hexDump, countLines } from "./text-sniff.js";
 import { gitDirOf, isNotRepoError, scmStatus, scmHistory, scmFileDiff, scmCommitDetail } from "./scm.js";
 export const IS_WIN32 = process.platform === "win32";
@@ -209,6 +210,10 @@ export class FilesService {
         }
         return [{ name: "/", path: "/", type: "dir" }];
     }
+    /** 单字段错误文本的语言（host 未接线时英文默认）。 */
+    lang() {
+        return this.host.getLang?.() ?? "en";
+    }
     /** 目录列表失败的 notice：缺失路径（ENOENT/ENOTDIR）是删除/改名等正常场景，
      *  软提示“目录不存在”；其余（权限拒绝等）保留原平台语义——win32 软提示
      *  （ACL 系统目录常见），posix 硬错误（error 级 notice，取代曾经的 throw）。 */
@@ -392,12 +397,12 @@ export class FilesService {
             this.watchGitDir(cwd);
         try {
             if (kind === "status") {
-                const data = await scmStatus(cwd);
+                const data = await scmStatus(cwd, () => this.lang());
                 this.host.emit({ type: "scm_data", reqId, kind, ok: true, ...data });
                 return;
             }
             if (kind === "history") {
-                const history = await scmHistory(cwd);
+                const history = await scmHistory(cwd, () => this.lang());
                 this.host.emit({ type: "scm_data", reqId, kind, ok: true, history });
                 return;
             }
@@ -407,8 +412,8 @@ export class FilesService {
                 const { resolve, relative } = await import("node:path");
                 const rel = relative(resolve(cwd), resolve(cwd, arg.path));
                 if (rel.startsWith("..") || rel === "")
-                    throw new Error("路径超出工作区");
-                const { staged, worktree } = await scmFileDiff(cwd, arg.path);
+                    throw new Error(pick(this.lang(), "路径超出工作区", "Path is outside the workspace", "files.path.outside.workspace"));
+                const { staged, worktree } = await scmFileDiff(cwd, arg.path, () => this.lang());
                 this.host.emit({
                     type: "scm_data",
                     reqId,
@@ -420,11 +425,11 @@ export class FilesService {
                 return;
             }
             if (kind === "commit" && arg?.hash && /^[0-9a-f]{7,40}$/i.test(arg.hash)) {
-                const text = await scmCommitDetail(cwd, arg.hash);
+                const text = await scmCommitDetail(cwd, arg.hash, () => this.lang());
                 this.host.emit({ type: "scm_data", reqId, kind, ok: true, text });
                 return;
             }
-            throw new Error("无效的 scm 查询参数");
+            throw new Error(pick(this.lang(), "无效的 scm 查询参数", "Invalid scm query arguments", "files.scm.invalid.args"));
         }
         catch (err) {
             if (isNotRepoError(err)) {
@@ -885,7 +890,7 @@ export class FilesService {
             const home = homedir();
             let expanded = input.trim();
             if (!expanded)
-                throw new Error("路径为空");
+                throw new Error(pick(this.lang(), "路径为空", "Empty path", "files.path.empty"));
             if (expanded === "~" || expanded === "~\\") {
                 expanded = home;
             }

package/dist/server/goal-service.js

@@ -15,6 +15,7 @@
 import { join } from "node:path";
 import { Type } from "typebox";
 import { createAgentSessionFromServices, createAgentSessionServices, defineTool, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { bilingual, pick } from "./i18n.js";
 import { parseModelSpec } from "./attachments.js";
 /** System prompt for the goal-wizard session. The wizard asks the user a few
  *  questions (via its goal_ask tool) to scope a raw requirement into a precise,
@@ -75,6 +76,14 @@ export class GoalService {
     get reviewPrefs() {
         return this.prefs;
     }
+    /** 当前服务端语言（英文默认，未接线前保持原有英文行为）。 */
+    lang() {
+        return this.host.lang?.() ?? "en";
+    }
+    /** 目标模式总开关（设置面板可关）。关 → 所有目标入口拒绝、审查不再触发。 */
+    goalEnabled() {
+        return this.host.goalModeEnabled();
+    }
     /** Create independent goal state for one conversation. Preferences are
      * client-wide defaults, while goal text/review progress is not shared. */
     makeGoalStatus() {
@@ -120,6 +129,15 @@ export class GoalService {
             await this.clearGoal();
             return;
         }
+        if (!this.goalEnabled()) {
+            this.host.emit({
+                type: "notice",
+                level: "warning",
+                text: "目标模式已关闭：请先在设置「目标审查」中启用目标模式。",
+                textEn: "Goal mode is off: enable it under Settings → Goal review first.",
+            });
+            return;
+        }
         // A goal is scoped to the conversation that is active when it is set.
         // This prevents an agent_end from a newly-created/switched conversation
         // from consuming the previous conversation's goal.
@@ -175,7 +193,8 @@ export class GoalService {
         if (opts?.autoStart !== false) {
             try {
                 const s = conv.session;
-                await s.sendUserMessage(`【目标已设定】\n\n${text}\n\n请现在开始实现这个目标。`, {
+                const kick = pick(this.lang(), `【目标已设定】\n\n${text}\n\n请现在开始实现这个目标。`, `[Goal set]\n\n${text}\n\nStart implementing this goal now.`, "goal.set.kick", { text: text });
+                await s.sendUserMessage(kick, {
                     deliverAs: s.isStreaming ? "steer" : "followUp",
                 });
             }
@@ -196,6 +215,15 @@ export class GoalService {
     async startGoalWizard(text, opts) {
         if (this.host.quiesceBlocked())
             return;
+        if (!this.goalEnabled()) {
+            this.host.emit({
+                type: "notice",
+                level: "warning",
+                text: "目标模式已关闭：请先在设置「目标审查」中启用目标模式。",
+                textEn: "Goal mode is off: enable it under Settings → Goal review first.",
+            });
+            return;
+        }
         const draft = (text ?? "").trim();
         if (!draft)
             return;
@@ -272,7 +300,7 @@ export class GoalService {
             idleTimer = setTimeout(() => {
                 if (!ac.signal.aborted) {
                     this.wizardCancelled = true;
-                    ac.abort(new Error("目标调研超时（等待回答过久）"));
+                    ac.abort(new Error(pick(this.lang(), "目标调研超时（等待回答过久）", "Goal survey timed out (waited too long for an answer)", "goal.wizard.idle.timeout")));
                 }
             }, GoalService.WIZARD_IDLE_TIMEOUT_MS);
             idleTimer.unref?.();
@@ -289,7 +317,7 @@ export class GoalService {
         const totalTimer = setTimeout(() => {
             if (!ac.signal.aborted) {
                 this.wizardCancelled = true;
-                ac.abort(new Error("目标调研超过总时长上限"));
+                ac.abort(new Error(pick(this.lang(), "目标调研超过总时长上限", "Goal survey exceeded the total time limit", "goal.wizard.total.timeout")));
             }
         }, GoalService.WIZARD_MAX_TOTAL_MS);
         totalTimer.unref?.();
@@ -326,9 +354,9 @@ export class GoalService {
             const goalAsk = defineTool({
                 name: "goal_ask",
                 label: "Ask the user",
-                description: "Ask the user ONE question at a time to scope down the goal. Provide a clear question and 2-4 concise options; or ask an open question. Returns the user's chosen answer.",
+                description: bilingual("Ask the user ONE question at a time to scope down the goal. Provide a clear question and 2-4 concise options; or ask an open question. Returns the user's chosen answer.", "一次只向用户提一个问题，以明确目标范围。给出清晰的问题和 2-4 个简洁选项；或提开放式问题。返回用户选择的答案。"),
                 parameters: Type.Object({
-                    question: Type.String({ description: "The question to ask" }),
+                    question: Type.String({ description: bilingual("The question to ask", "要问的问题") }),
                     options: Type.Optional(Type.Array(Type.String())),
                 }),
                 // ONE question at a time. Sequential execution prevents the agent from
@@ -337,13 +365,14 @@ export class GoalService {
                 // reported "调研卡住").
                 executionMode: "sequential",
                 execute: async (_id, params, _sig, _onUpdate, ctx) => {
+                    const lang = this.lang();
                     qStep += 1;
                     if (qStep > maxSteps) {
                         return {
                             content: [
                                 {
                                     type: "text",
-                                    text: "(达到最大提问数，请直接给出收敛后的目标文本作为最终答案)",
+                                    text: pick(lang, "(达到最大提问数，请直接给出收敛后的目标文本作为最终答案)", "(Max questions reached — stop asking and reply with the converged goal text as your final answer)", "goal.wizard.max.questions"),
                                 },
                             ],
                             details: {},
@@ -358,16 +387,23 @@ export class GoalService {
                     try {
                         armIdle();
                         const isChoice = !!(params.options && params.options.length > 0);
-                        await this.pushWizardCard(mainSession, `🔍 第 ${qStep} 题：${params.question}${isChoice ? `【${params.options.join(" / ")}】` : ""}`, { question: params.question });
+                        const qTitle = pick(lang, `🔍 第 ${qStep} 题：${params.question}`, `🔍 Question ${qStep}: ${params.question}`, "goal.wizard.question.title", { qStep: qStep, "params.question": params.question });
+                        const optionsJoined = params.options.join(" / ");
+                        const choiceSuffixZh = isChoice ? `【${optionsJoined}】` : "";
+                        const choiceSuffixEn = isChoice ? ` [${optionsJoined}]` : "";
+                        await this.pushWizardCard(mainSession, pick(lang, `🔍 第 ${qStep} 题：${params.question}${choiceSuffixZh}`, `🔍 Question ${qStep}: ${params.question}${choiceSuffixEn}`, "goal.wizard.question.card", {
+                            qStep: qStep,
+                            "params.question": params.question,
+                            choiceSuffixZh: choiceSuffixZh,
+                            choiceSuffixEn: choiceSuffixEn,
+                        }), { question: params.question });
                         // Resolve the pending dialog as cancelled if the wizard is aborted.
                         let aborted = false;
                         const onAbort = () => {
                             aborted = true;
                         };
                         ac.signal.addEventListener("abort", onAbort, { once: true });
-                        const choose = isChoice
-                            ? ctx.ui.select(`🔍 第 ${qStep} 题：${params.question}`, params.options)
-                            : ctx.ui.input(`🔍 第 ${qStep} 题：${params.question}`);
+                        const choose = isChoice ? ctx.ui.select(qTitle, params.options) : ctx.ui.input(qTitle);
                         const ans = (await choose);
                         ac.signal.removeEventListener("abort", onAbort);
                         if (aborted || ac.signal.aborted) {
@@ -375,7 +411,7 @@ export class GoalService {
                                 content: [
                                     {
                                         type: "text",
-                                        text: "(调研已取消，请不要继续提问，直接结束对话)",
+                                        text: pick(lang, "(调研已取消，请不要继续提问，直接结束对话)", "(The survey was cancelled — stop asking and end the conversation)", "goal.wizard.cancelled.stop"),
                                     },
                                 ],
                                 details: {},
@@ -386,30 +422,40 @@ export class GoalService {
                                 content: [
                                     {
                                         type: "text",
-                                        text: "(用户已取消调研，请直接给出你当前收敛的目标文本作为最终答案)",
+                                        text: pick(lang, "(用户已取消调研，请直接给出你当前收敛的目标文本作为最终答案)", "(The user cancelled the survey — reply with your best-effort goal text as the final answer)", "goal.wizard.cancelled.best"),
                                     },
                                 ],
                                 details: {},
                             };
                         }
                         // Record the answer in the flow too (instant append, main session idle).
-                        await this.pushWizardCard(mainSession, `↳ 您的回答：${ans}`, {
+                        await this.pushWizardCard(mainSession, pick(lang, `↳ 您的回答：${ans}`, `↳ Your answer: ${ans}`, "goal.wizard.answer.card", { ans: ans }), {
                             question: params.question,
                             answer: String(ans),
                         });
                         return {
-                            content: [{ type: "text", text: `用户回答：${ans}` }],
+                            content: [
+                                {
+                                    type: "text",
+                                    text: pick(lang, `用户回答：${ans}`, `User answer: ${ans}`, "goal.wizard.answer.return", {
+                                        ans: ans,
+                                    }),
+                                },
+                            ],
                             details: {},
                         };
                     }
                     catch (err) {
+                        const errMsg = err.message;
                         return {
                             content: [
                                 {
                                     type: "text",
                                     text: ac.signal.aborted
-                                        ? "(调研已取消，请不要继续提问，直接结束对话)"
-                                        : `提问失败：${err.message}`,
+                                        ? pick(lang, "(调研已取消，请不要继续提问，直接结束对话)", "(The survey was cancelled — stop asking and end the conversation)", "goal.wizard.cancelled.aborted")
+                                        : pick(lang, `提问失败：${errMsg}`, `Failed to ask: ${errMsg}`, "goal.wizard.ask.failed", {
+                                            errMsg: errMsg,
+                                        }),
                                 },
                             ],
                             details: {},
@@ -526,7 +572,8 @@ export class GoalService {
         // The kick-off is a user message so it appears in the flow and triggers a
         // normal turn; the finishing agent_end then runs the review loop.
         try {
-            await mainSession.sendUserMessage(`【目标已设定】\n\n${wgoal.goal}\n\n请现在开始实现这个目标。`, {
+            const wizardKick = pick(this.lang(), `【目标已设定】\n\n${wgoal.goal}\n\n请现在开始实现这个目标。`, `[Goal set]\n\n${wgoal.goal}\n\nStart implementing this goal now.`, "goal.wizard.kick", { "wgoal.goal": wgoal.goal });
+            await mainSession.sendUserMessage(wizardKick, {
                 deliverAs: mainSession.isStreaming ? "steer" : "followUp",
             });
         }
@@ -538,6 +585,8 @@ export class GoalService {
      *  touching the active goal — so changes in the goal bar are remembered across
      *  reloads. maxRounds 0 = unlimited. Emits goal_status so the UI stays synced. */
     async setGoalPrefs(opts) {
+        if (!this.goalEnabled())
+            return;
         const goal = this.host.activeConv().goal;
         if (opts?.reviewModel !== undefined)
             goal.reviewModel = opts.reviewModel || null;
@@ -621,7 +670,12 @@ export class GoalService {
         // Goal review hook: after the run finished normally, if a goal is
         // active (and it belonged to the ACTIVE conversation) and we're not
         // already mid-review, spawn the isolated reviewer.
-        if (g.goal && g.conversationId === conv.id && !g.reviewing && !conv.wizardRunning && !this.host.isDisposed()) {
+        if (g.goal &&
+            g.conversationId === conv.id &&
+            !g.reviewing &&
+            !conv.wizardRunning &&
+            !this.host.isDisposed() &&
+            this.goalEnabled()) {
             void this.runGoalReview(conv);
         }
         return null;
@@ -743,7 +797,7 @@ export class GoalService {
             return;
         }
         let reviewerVerdict = "fail";
-        let reviewerFeedback = "（审查无法完成）";
+        let reviewerFeedback = pick(this.lang(), "（审查无法完成）", "(The review could not be completed)", "goal.review.incomplete");
         try {
             const rmSpec = this.resolveReviewModel(g.reviewModel);
             const services = await createAgentSessionServices({
@@ -800,8 +854,9 @@ export class GoalService {
             await srv.session.dispose();
         }
         catch (err) {
+            const reviewErrMsg = err.message;
             reviewerVerdict = "fail";
-            reviewerFeedback = `审查过程中出错：${err.message}`;
+            reviewerFeedback = pick(this.lang(), `审查过程中出错：${reviewErrMsg}`, `Error during review: ${reviewErrMsg}`, "goal.review.error", { reviewErrMsg: reviewErrMsg });
         }
         // The user may have switched chats or replaced/cleared the goal while the
         // isolated reviewer was running. Never apply a stale verdict or inject it
@@ -833,7 +888,8 @@ export class GoalService {
             // USER the outcome and hands the main agent back out of "goal mode", so a
             // follow-up instruction like "发布" is a normal request — not a confirm echo.
             try {
-                await mainSession.sendUserMessage(`✅ 目标已达成并通过审查（第 ${round} 轮）。\n\n目标：${goalText}\n\n${feedback}\n\n（目标模式已解除，接下来按你的普通指令响应。）`, { deliverAs: mainSession.isStreaming ? "steer" : "followUp" });
+                const passText = pick(this.lang(), `✅ 目标已达成并通过审查（第 ${round} 轮）。\n\n目标：${goalText}\n\n${feedback}\n\n（目标模式已解除，接下来按你的普通指令响应。）`, `✅ Goal achieved and passed review (round ${round}).\n\nGoal: ${goalText}\n\n${feedback}\n\n(Goal mode is off — respond to further instructions normally.)`, "goal.review.pass", { round: round, goalText: goalText, feedback: feedback });
+                await mainSession.sendUserMessage(passText, { deliverAs: mainSession.isStreaming ? "steer" : "followUp" });
             }
             catch {
                 // Best-effort.
@@ -856,8 +912,11 @@ export class GoalService {
             // Inject the reviewer's feedback into the main session to revise (this IS
             // the fail review result, as an ordinary user message — no separate card).
             try {
-                const steerText = `【目标审查：第 ${g.round}/${budgetForCard > 0 ? budgetForCard : "不限"} 轮未通过】\n\n目标：${goalText}\n\n` +
-                    `审查意见：${feedback}\n\n请根据以上意见修改你的成果，使其完全满足目标。`;
+                const capped = budgetForCard > 0 ? budgetForCard : "不限";
+                const cappedEn = budgetForCard > 0 ? budgetForCard : "unlimited";
+                const steerText = pick(this.lang(), `【目标审查：第 ${g.round}/${capped} 轮未通过】\n\n目标：${goalText}\n\n` +
+                    `审查意见：${feedback}\n\n请根据以上意见修改你的成果，使其完全满足目标。`, `[Goal review: round ${g.round}/${cappedEn} failed]\n\nGoal: ${goalText}\n\n` +
+                    `Feedback: ${feedback}\n\nRevise your work based on the feedback above so it fully satisfies the goal.`, "goal.review.revise", { "g.round": g.round, capped: capped, goalText: goalText, feedback: feedback, cappedEn: cappedEn });
                 await mainSession.sendUserMessage(steerText, {
                     deliverAs: mainSession.isStreaming ? "steer" : "followUp",
                 });
@@ -882,7 +941,9 @@ export class GoalService {
             g.statusEn = `Goal failed (${roundsEn})`;
         }
         try {
-            await mainSession.sendUserMessage(`❌ 目标未通过审查（第 ${round}/${budgetForCard > 0 ? budgetForCard : "不限"} 轮）。\n\n目标：${goalText}\n\n审查意见：${feedback}`, { deliverAs: mainSession.isStreaming ? "steer" : "followUp" });
+            const capped = budgetForCard > 0 ? budgetForCard : "不限";
+            const cappedEn = budgetForCard > 0 ? budgetForCard : "unlimited";
+            await mainSession.sendUserMessage(pick(this.lang(), `❌ 目标未通过审查（第 ${round}/${capped} 轮）。\n\n目标：${goalText}\n\n审查意见：${feedback}`, `❌ Goal failed review (round ${round}/${cappedEn}).\n\nGoal: ${goalText}\n\nFeedback: ${feedback}`, "goal.review.fail", { round: round, capped: capped, goalText: goalText, feedback: feedback, cappedEn: cappedEn }), { deliverAs: mainSession.isStreaming ? "steer" : "followUp" });
         }
         catch {
             // Best-effort.