kcode-pi 0.1.14 → 0.1.15

package/README.md

@@ -2,6 +2,8 @@
 
 KCode 是面向金蝶开发的 Pi 工作环境启动器。安装后会提供全局命令 `kcode`，自动携带 Pi CLI，并在当前业务项目中加载金蝶专属工具、skills、prompts、themes 和知识库。
 
+KCode 默认面向中文用户：README、`kcode help`、Pi 内 `/kd-*` 命令说明、工具参数说明、内置 prompts 和 Harness 阶段文档模板均使用中文。命令名和产品标识仍保持英文，例如 `/kd-start`、`kd_search`、`flagship`。
+
 KCode 不要求你单独安装全局 `pi` 命令，也不会修改用户全局 Pi 配置。它只维护当前项目的：
 
 ```text
@@ -289,17 +291,17 @@ kcode start --provider openai --model gpt-4o
 进入 `kcode start` 后，可以使用以下 KCode 命令：
 
 ```text
-/kd-start [--product product] [--version version] <goal>
-/kd-product <product> [--version version]
+/kd-start [--product 产品] [--version 版本] <需求>
+/kd-product <产品> [--version 版本]
 /kd-status
 /kd-runs
 /kd-switch <run-id>
 /kd-resume [补充说明]
 /kd-finish
 /kd-gate
-/kd-advance [phase]
-/kd-artifact [phase] [content]
-/kd-answer Q-001 <answer>
+/kd-advance [阶段]
+/kd-artifact [阶段] [内容]
+/kd-answer Q-001 <答案>
 ```
 
 典型开始方式：
@@ -393,8 +395,8 @@ ship     汇总变更、验证证据、风险和后续事项
 
 - 未进入 `execute` 阶段时，KCode 会阻止写入 Java/XML/SQL 等产品代码。
 - 进入 `execute` 前必须已有 `PLAN.md` 和必要证据。
-- `PLAN.md` 必须包含 `## Execution Steps`，并用 `- [ ] STEP-001: ...` 格式拆分可跟踪步骤。
-- `PLAN.md` 必须包含 `## TDD / Red-Green Checks`，声明红灯证据、绿灯证据和测试/检查命令。
+- `PLAN.md` 必须包含 `## 执行步骤`，并用 `- [ ] STEP-001：...` 格式拆分可跟踪步骤。
+- `PLAN.md` 必须包含 `## TDD / 红绿检查`，声明红灯证据、绿灯证据和测试/检查命令。
 - 红绿检查不等于必须写 JUnit。金蝶项目不要为了满足门禁引入额外 jar 或测试框架。
 - 写生产源码前必须已有 `evidence/tdd-red.md`，内容可以是 API/基类/方法签名检查、元数据检查、编译检查、既有测试框架或外部接口最小验证的失败输出。
 - 进入 `execute` 后，只允许写入 `PLAN.md` 明确列出的源码文件；如果临时发现要改新文件，必须先回到 plan 更新 `PLAN.md`。
@@ -405,36 +407,36 @@ ship     汇总变更、验证证据、风险和后续事项
 示例计划步骤：
 
 ```markdown
-## Execution Steps
+## 执行步骤
 
-- [ ] STEP-001: 检查现有插件基类、包名和目标字段。
-- [ ] STEP-002: 运行 API/元数据/编译等红灯检查并记录证据。
-- [ ] STEP-003: 修改 `code/scm/plugin/src/main/java/.../PurchaseOrderPlugin.java`。
-- [ ] STEP-004: 运行同一类绿灯检查并记录证据。
-- [ ] STEP-005: 记录变更文件和验证证据。
+- [ ] STEP-001：检查现有插件基类、包名和目标字段。
+- [ ] STEP-002：运行 API/元数据/编译等红灯检查并记录证据。
+- [ ] STEP-003：修改 `code/scm/plugin/src/main/java/.../PurchaseOrderPlugin.java`。
+- [ ] STEP-004：运行同一类绿灯检查并记录证据。
+- [ ] STEP-005：记录变更文件和验证证据。
 ```
 
 示例红绿检查：
 
 ```markdown
-## TDD / Red-Green Checks
+## TDD / 红绿检查
 
-- Red evidence: evidence/tdd-red.md
-- Green evidence: evidence/tdd-green.md
-- Red/green command or tool: kd_sdk_signature / kd_cosmic_metadata / kd_check / build
-- Do not add third-party test jars or frameworks only for this gate.
+- 红灯证据：evidence/tdd-red.md
+- 绿灯证据：evidence/tdd-green.md
+- 红绿检查命令或工具：kd_sdk_signature / kd_cosmic_metadata / kd_check / build
+- 不要为了满足门禁引入第三方测试 jar 或测试框架。
 ```
 
 示例执行记录：
 
 ```markdown
-## Step Results
+## 步骤结果
 
-- [x] STEP-001: completed. Evidence: evidence/step-001.md
-- [x] STEP-002: completed. Evidence: evidence/step-002.md
-- [x] STEP-003: completed. Evidence: evidence/step-003.md
-- [x] STEP-004: completed. Evidence: evidence/tdd-green.md
-- [x] STEP-005: completed. Evidence: evidence/step-005.md
+- [x] STEP-001：已完成。证据：evidence/step-001.md
+- [x] STEP-002：已完成。证据：evidence/step-002.md
+- [x] STEP-003：已完成。证据：evidence/step-003.md
+- [x] STEP-004：已完成。证据：evidence/tdd-green.md
+- [x] STEP-005：已完成。证据：evidence/step-005.md
 ```
 
 如果 LLM 跳过步骤、没有记录 evidence，或只是口头声明完成，KCode 不允许进入 `verify`。
@@ -449,7 +451,7 @@ ship     汇总变更、验证证据、风险和后续事项
 
 得到回答后，再继续问触发时机、库存条件、弹窗内容或插件位置。
 
-在 `kcode start` 的交互式 TUI 中，`kd_question` 会弹出 KCode Question 选择/输入对话，并在用户选择或输入后自动记录答案。非交互模式或 UI 不可用时，问题会显示在对话里，用户直接回复；Agent 读取回复后再记录答案。也可以手动执行：
+在 `kcode start` 的交互式 TUI 中，`kd_question` 会弹出 KCode 问题选择/输入对话，并在用户选择或输入后自动记录答案。非交互模式或 UI 不可用时，问题会显示在对话里，用户直接回复；Agent 读取回复后再记录答案。也可以手动执行：
 
 ```text
 /kd-answer Q-001 采购订单

package/dist/context/project-context.js

@@ -47,33 +47,33 @@ export function generateProjectContext(cwd) {
     const buildFiles = scan.files.filter((file) => BUILD_FILE_NAMES.has(basename(file).toLowerCase()) || isSolutionOrProject(file));
     const sourceSamples = scan.files.filter((file) => SOURCE_EXTENSIONS.has(extname(file).toLowerCase())).slice(0, MAX_SOURCE_SAMPLES);
     return [
-        "# KCode Project Context",
+        "# KCode 项目上下文",
         "",
-        `- Project root: ${cwd}`,
-        `- Project name: ${basename(cwd)}`,
-        `- Generated at: ${new Date().toISOString()}`,
+        `- 项目根目录：${cwd}`,
+        `- 项目名称：${basename(cwd)}`,
+        `- 生成时间：${new Date().toISOString()}`,
         "",
-        "## Persistent Rules",
+        "## 持久规则",
         "",
-        "- This file is project memory for KCode. Read it before planning or editing code.",
-        "- Do not create demo/sample/scaffold code for business requirements.",
-        "- Do not assume module layout. Follow the actual paths below and verify target files before editing.",
-        "- Use project-relative paths when calling file tools. On Windows, do not rewrite paths to /mnt/<drive>/... or /<drive>/...; use Windows paths only when an absolute path is necessary.",
-        "- If this file is stale, regenerate with `kcode context --refresh` before planning.",
-        "- Write product code only after the Harness reaches `execute` and PLAN.md names the real target path.",
+        "- 本文件是 KCode 的项目记忆，计划或编辑代码前必须读取。",
+        "- 业务需求不得生成 demo/sample/scaffold 代码。",
+        "- 不要假设模块结构。必须基于下方真实路径，并在编辑前确认目标文件。",
+        "- 调用文件工具时优先使用项目相对路径。在 Windows 中，不要把路径改写为 /mnt/<drive>/... 或 /<drive>/...；只有确需绝对路径时才使用 Windows 路径。",
+        "- 如果本文件过期，计划前先运行 `kcode context --refresh` 重新生成。",
+        "- 只有 Harness 进入 `execute` 且 PLAN.md 写明真实目标路径后，才能写产品代码。",
         "",
-        "## Layout Summary",
+        "## 项目结构摘要",
         "",
-        `- Has code directory: ${codeDir ? "yes" : "no"}`,
-        `- Likely source roots: ${formatList(likelyRoots)}`,
-        `- Build files: ${formatList(buildFiles)}`,
-        `- Detected modules: ${formatList(modules)}`,
+        `- 是否存在 code 目录：${codeDir ? "是" : "否"}`,
+        `- 可能的源码根：${formatList(likelyRoots)}`,
+        `- 构建文件：${formatList(buildFiles)}`,
+        `- 识别到的模块：${formatList(modules)}`,
         "",
-        "## Source Samples",
+        "## 源码样例",
         "",
         formatBlockList(sourceSamples),
         "",
-        "## Top-Level Directories",
+        "## 顶层目录",
         "",
         formatBlockList(scan.directories.filter((dir) => !dir.includes("/") && !dir.includes("\\")).sort()),
         "",
@@ -181,11 +181,11 @@ function isSolutionOrProject(file) {
     return [".sln", ".csproj"].includes(extname(file).toLowerCase());
 }
 function formatList(values) {
-    return values.length > 0 ? values.join(", ") : "none detected";
+    return values.length > 0 ? values.join(", ") : "未识别";
 }
 function formatBlockList(values) {
     if (values.length === 0)
-        return "- none detected";
+        return "- 未识别";
     return values.map((value) => `- ${value}`).join("\n");
 }
 function normalize(path) {

package/extensions/kingdee-harness.ts

@@ -84,7 +84,7 @@ function sendWorkflowPrompt(pi: ExtensionAPI, ctx: ExtensionContext, run: NonNul
 		return;
 	}
 	pi.sendUserMessage(prompt, { deliverAs: "followUp" });
-	if (ctx.hasUI) ctx.ui.notify("KCode harness message queued.", "info");
+	if (ctx.hasUI) ctx.ui.notify("KCode 工作流消息已排队。", "info");
 }
 
 function workflowPromptForRun(cwd: string, run: NonNullable<ReturnType<typeof readActiveRun>>, userText: string): string {
@@ -163,8 +163,8 @@ function codeWriteBlockReason(cwd: string, path: string | undefined): string | u
 
 const kdPlanStatusTool = defineTool({
 	name: "kd_plan_status",
-	label: "KD Status",
-	description: "Inspect the active Kingdee Harness Engineering run, current phase, required artifacts, and gate status.",
+	label: "KD 状态",
+	description: "查看当前金蝶 Harness run、当前阶段、必需文档和门禁状态。",
 	parameters: Type.Object({}),
 
 	async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
@@ -178,24 +178,24 @@ const kdPlanStatusTool = defineTool({
 
 const kdQuestionTool = defineTool({
 	name: "kd_question",
-	label: "KD Question",
+	label: "KD 问题",
 	description:
-		"Create, answer, or list structured Kingdee Harness questions. Ask exactly one short blocking question at a time; do not batch a checklist.",
+		"创建、回答或列出金蝶 Harness 结构化问题。每次只能问一个最阻塞的短问题，不要批量列清单。",
 	parameters: Type.Object({
-		action: Type.Optional(Type.String({ description: "ask, answer, or list. Defaults to ask." })),
-		id: Type.Optional(Type.String({ description: "Question id when action=answer, for example Q-001." })),
-		question: Type.Optional(Type.String({ description: "One short question to ask when action=ask. No numbered lists or multiple questions." })),
-		answer: Type.Optional(Type.String({ description: "User answer when action=answer." })),
-		reason: Type.Optional(Type.String({ description: "Why this question blocks or matters." })),
-		choices: Type.Optional(Type.Array(Type.String(), { description: "Optional concrete choices for the user, maximum 3 short labels." })),
-		blocking: Type.Optional(Type.Boolean({ description: "Whether the question blocks phase advancement. Defaults to true." })),
+		action: Type.Optional(Type.String({ description: "操作类型：ask、answer 或 list，默认 ask。" })),
+		id: Type.Optional(Type.String({ description: "回答问题时的问题编号，例如 Q-001。" })),
+		question: Type.Optional(Type.String({ description: "提问内容。只能是一个短问题，不要写编号清单或多个问题。" })),
+		answer: Type.Optional(Type.String({ description: "用户答案，action=answer 时使用。" })),
+		reason: Type.Optional(Type.String({ description: "说明为什么这个问题会阻塞当前阶段。" })),
+		choices: Type.Optional(Type.Array(Type.String(), { description: "可选项，最多 3 个简短选项。" })),
+		blocking: Type.Optional(Type.Boolean({ description: "是否阻塞阶段推进，默认 true。" })),
 	}),
 
 	async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
 		const run = readActiveRun(ctx.cwd);
 		if (!run) {
 			return {
-				content: [{ type: "text", text: "No active Kingdee harness run. Start one with /kd-start <goal> first." }],
+				content: [{ type: "text", text: "当前没有 active Kingdee Harness run。请先使用 /kd-start <需求> 创建。" }],
 				details: { error: "no-active-run" },
 			};
 		}
@@ -209,34 +209,34 @@ const kdQuestionTool = defineTool({
 		if (action === "answer") {
 			if (!params.id || !params.answer) {
 				return {
-					content: [{ type: "text", text: "kd_question action=answer requires id and answer." }],
+					content: [{ type: "text", text: "kd_question action=answer 需要同时提供 id 和 answer。" }],
 					details: { error: "missing-answer-params" },
 				};
 			}
 			const answered = answerQuestion(ctx.cwd, run, params.id, params.answer);
 			if (!answered) {
 				return {
-					content: [{ type: "text", text: `Question not found: ${params.id}` }],
+					content: [{ type: "text", text: `未找到问题：${params.id}` }],
 					details: { error: "question-not-found", id: params.id },
 				};
 			}
-			appendQuestionEventToArtifact(ctx.cwd, run, [`- Answered ${answered.id}: ${answered.answer}`]);
+			appendQuestionEventToArtifact(ctx.cwd, run, [`- 已回答 ${answered.id}：${answered.answer}`]);
 			return {
-				content: [{ type: "text", text: `Recorded answer for ${answered.id}. Gate refreshed.` }],
+				content: [{ type: "text", text: `已记录 ${answered.id} 的答案，并刷新门禁。` }],
 				details: { question: answered, gate: readActiveRun(ctx.cwd)?.gate },
 			};
 		}
 
 		if (action !== "ask") {
 			return {
-				content: [{ type: "text", text: `Unknown kd_question action: ${params.action}. Use ask, answer, or list.` }],
+				content: [{ type: "text", text: `未知 kd_question action：${params.action}。请使用 ask、answer 或 list。` }],
 				details: { error: "unknown-action", action: params.action },
 			};
 		}
 
 		if (!params.question?.trim()) {
 			return {
-				content: [{ type: "text", text: "kd_question action=ask requires question." }],
+				content: [{ type: "text", text: "kd_question action=ask 需要提供 question。" }],
 				details: { error: "missing-question" },
 			};
 		}
@@ -272,15 +272,15 @@ const kdQuestionTool = defineTool({
 		if (interactiveAnswer) {
 			const answered = answerQuestion(ctx.cwd, run, question.id, interactiveAnswer);
 			if (answered) {
-				appendQuestionEventToArtifact(ctx.cwd, run, [`- Answered ${answered.id}: ${answered.answer}`]);
+				appendQuestionEventToArtifact(ctx.cwd, run, [`- 已回答 ${answered.id}：${answered.answer}`]);
 				return {
-					content: [{ type: "text", text: `User answered ${answered.id}: ${answered.answer}` }],
+					content: [{ type: "text", text: `用户已回答 ${answered.id}：${answered.answer}` }],
 					details: { question: answered, gate: readActiveRun(ctx.cwd)?.gate, answered: true },
 				};
 			}
 		}
 
-		const text = `${formatQuestionCard(question)}\n\nInteractive answer was not provided; keep this question open until the user answers.`;
+		const text = `${formatQuestionCard(question)}\n\n未获得交互式答案；在用户回答前，该问题会保持 open。`;
 		return { content: [{ type: "text", text }], details: { question, gate: readActiveRun(ctx.cwd)?.gate, answered: false } };
 	},
 });
@@ -309,7 +309,7 @@ export default function (pi: ExtensionAPI) {
 		if (!run && shouldStartHarnessFromInput(event.text)) {
 			run = createActiveRun(ctx.cwd, event.text);
 			if (ctx.hasUI) {
-				ctx.ui.notify(`Started Kingdee harness run: ${run.id} (${run.profile?.product}/${run.profile?.techStack})`, "info");
+				ctx.ui.notify(`已启动 Kingdee Harness run：${run.id}（${run.profile?.product}/${run.profile?.techStack}）`, "info");
 			}
 		}
 
@@ -341,14 +341,14 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.registerCommand("kd-status", {
-		description: "Show the active Kingdee harness run and gate status",
+		description: "查看当前 Kingdee Harness run 和门禁状态",
 		handler: async (_args, ctx) => {
 			ctx.ui.notify(formatStatus(ctx.cwd, readActiveRun(ctx.cwd)), "info");
 		},
 	});
 
 	pi.registerCommand("kd-runs", {
-		description: "List Kingdee harness runs for this project",
+		description: "列出当前项目的 Kingdee Harness run",
 		handler: async (_args, ctx) => {
 			const active = readActiveRun(ctx.cwd);
 			ctx.ui.notify(formatRuns(listRuns(ctx.cwd), active?.id), "info");
@@ -356,46 +356,46 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.registerCommand("kd-gate", {
-		description: "Refresh and show the active Kingdee harness gate",
+		description: "刷新并查看当前 Kingdee Harness 门禁",
 		handler: async (_args, ctx) => {
 			const run = requireRun(ctx.cwd);
 			if (!run) {
-				ctx.ui.notify("No active Kingdee harness run. Use /kd-start <goal>.", "error");
+				ctx.ui.notify("当前没有 active Kingdee Harness run。请使用 /kd-start <需求>。", "error");
 				return;
 			}
 			const refreshed = refreshGate(ctx.cwd, run);
-			ctx.ui.notify(refreshed.gate.passed ? "Gate passed" : `Gate blocked: ${refreshed.gate.reason}`, "info");
+			ctx.ui.notify(refreshed.gate.passed ? "门禁通过" : `门禁阻塞：${refreshed.gate.reason}`, "info");
 		},
 	});
 
 	pi.registerCommand("kd-start", {
-		description: "Start a Kingdee harness run: /kd-start [--product product] [--version version] <goal>",
+		description: "启动一个 Kingdee Harness run：/kd-start [--product 产品] [--version 版本] <需求>",
 		handler: async (args, ctx) => {
 			const parsed = parseStartArgs(args);
 			const goal = parsed.goal;
 			if (!goal) {
-				ctx.ui.notify("Usage: /kd-start [--product product] [--version version] <goal>", "error");
+				ctx.ui.notify("用法：/kd-start [--product 产品] [--version 版本] <需求>", "error");
 				return;
 			}
 
 			const run = createActiveRun(ctx.cwd, goal, parsed.product, parsed.version);
-			ctx.ui.notify(`Started Kingdee harness run: ${run.id} (${run.profile?.product}/${run.profile?.techStack})`, "info");
+			ctx.ui.notify(`已启动 Kingdee Harness run：${run.id}（${run.profile?.product}/${run.profile?.techStack}）`, "info");
 			sendWorkflowPrompt(pi, ctx, run, `继续 KCode Harness run ${run.id}：${goal}`);
 		},
 	});
 
 	pi.registerCommand("kd-resume", {
-		description: "Resume the active Kingdee harness run and inject persisted context",
+		description: "接续当前 Kingdee Harness run，并注入已落盘上下文",
 		handler: async (args, ctx) => {
 			const run = requireRun(ctx.cwd);
 			if (!run) {
-				ctx.ui.notify("No active Kingdee harness run. Use /kd-start <goal> or /kd-runs.", "error");
+				ctx.ui.notify("当前没有 active Kingdee Harness run。请使用 /kd-start <需求> 或 /kd-runs。", "error");
 				return;
 			}
 
 			const note = args.trim();
 			const message = [
-				`继续 KCode Harness run ${run.id}：${run.goal ?? "unknown goal"}`,
+				`继续 KCode Harness run ${run.id}：${run.goal ?? "未知需求"}`,
 				note ? `用户补充：${note}` : undefined,
 			]
 				.filter(Boolean)
@@ -405,64 +405,64 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.registerCommand("kd-switch", {
-		description: "Switch active Kingdee harness run: /kd-switch <run-id>",
+		description: "切换当前 active Kingdee Harness run：/kd-switch <run-id>",
 		handler: async (args, ctx) => {
 			const id = args.trim();
 			if (!id) {
-				ctx.ui.notify("Usage: /kd-switch <run-id>", "error");
+				ctx.ui.notify("用法：/kd-switch <run-id>", "error");
 				return;
 			}
 
 			const run = switchActiveRun(ctx.cwd, id);
 			if (!run) {
-				ctx.ui.notify(`Kingdee harness run not found: ${id}. Use /kd-runs to list runs.`, "error");
+				ctx.ui.notify(`未找到 Kingdee Harness run：${id}。请用 /kd-runs 查看列表。`, "error");
 				return;
 			}
 
-			ctx.ui.notify(`Switched active Kingdee harness run: ${run.id} (${run.phase})`, "info");
+			ctx.ui.notify(`已切换 active Kingdee Harness run：${run.id}（${run.phase}）`, "info");
 		},
 	});
 
 	pi.registerCommand("kd-finish", {
-		description: "Mark the active Kingdee harness run as done and clear active run",
+		description: "标记当前 Kingdee Harness run 完成，并清除 active run",
 		handler: async (_args, ctx) => {
 			const run = requireRun(ctx.cwd);
 			if (!run) {
-				ctx.ui.notify("No active Kingdee harness run. Use /kd-start <goal>.", "error");
+				ctx.ui.notify("当前没有 active Kingdee Harness run。请使用 /kd-start <需求>。", "error");
 				return;
 			}
 
 			const finished = finishActiveRun(ctx.cwd, run);
-			ctx.ui.notify(`Finished Kingdee harness run: ${finished.id}. Start the next feature with /kd-start <goal>.`, "info");
+			ctx.ui.notify(`已完成 Kingdee Harness run：${finished.id}。下一个功能点请使用 /kd-start <需求>。`, "info");
 		},
 	});
 
 	pi.registerCommand("kd-product", {
-		description: "Set the active Kingdee product profile: /kd-product <flagship|cosmic|xinghan|cangqiong|enterprise> [--version version]",
+		description: "设置当前金蝶产品画像：/kd-product <flagship|cosmic|xinghan|cangqiong|enterprise> [--version 版本]",
 		handler: async (args, ctx) => {
 			const run = requireRun(ctx.cwd);
 			if (!run) {
-				ctx.ui.notify("No active Kingdee harness run. Use /kd-start <goal>.", "error");
+				ctx.ui.notify("当前没有 active Kingdee Harness run。请使用 /kd-start <需求>。", "error");
 				return;
 			}
 
 			const parsed = parseProductArgs(args);
 			if (!parsed) {
-				ctx.ui.notify("Usage: /kd-product <flagship|cosmic|xinghan|cangqiong|enterprise> [--version version]", "error");
+				ctx.ui.notify("用法：/kd-product <flagship|cosmic|xinghan|cangqiong|enterprise> [--version 版本]", "error");
 				return;
 			}
 
 			const updated = updateProductProfile(ctx.cwd, run, parsed.product, parsed.version);
-			ctx.ui.notify(`Product profile: ${updated.profile?.product}/${updated.profile?.techStack}/${updated.profile?.language}`, "info");
+			ctx.ui.notify(`产品画像：${updated.profile?.product}/${updated.profile?.techStack}/${updated.profile?.language}`, "info");
 		},
 	});
 
 	pi.registerCommand("kd-advance", {
-		description: `Advance Kingdee run to the next phase or a named phase: ${PHASE_ORDER.join("|")}`,
+		description: `推进 Kingdee run 到下一阶段，或指定阶段：${PHASE_ORDER.join("|")}`,
 		handler: async (args, ctx) => {
 			const run = requireRun(ctx.cwd);
 			if (!run) {
-				ctx.ui.notify("No active Kingdee harness run. Use /kd-start <goal>.", "error");
+				ctx.ui.notify("当前没有 active Kingdee Harness run。请使用 /kd-start <需求>。", "error");
 				return;
 			}
 
@@ -470,7 +470,7 @@ export default function (pi: ExtensionAPI) {
 			let requested: KdPhase | undefined;
 			if (requestedText) {
 				if (!isKdPhase(requestedText)) {
-					ctx.ui.notify(`Unknown phase "${requestedText}". Valid phases: ${PHASE_ORDER.join(", ")}`, "error");
+					ctx.ui.notify(`未知阶段 "${requestedText}"。可用阶段：${PHASE_ORDER.join(", ")}`, "error");
 					return;
 				}
 				requested = requestedText;
@@ -482,67 +482,67 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.registerCommand("kd-artifact", {
-		description: "Create or update a phase artifact: /kd-artifact [phase] [content]",
+		description: "创建或更新阶段文档：/kd-artifact [阶段] [内容]",
 		handler: async (args, ctx) => {
 			const run = requireRun(ctx.cwd);
 			if (!run) {
-				ctx.ui.notify("No active Kingdee harness run. Use /kd-start <goal>.", "error");
+				ctx.ui.notify("当前没有 active Kingdee Harness run。请使用 /kd-start <需求>。", "error");
 				return;
 			}
 
 			const parsed = parseArtifactArgs(args, run.phase);
 			if (!parsed) {
-				ctx.ui.notify("Usage: /kd-artifact [phase] [content]", "error");
+				ctx.ui.notify("用法：/kd-artifact [阶段] [内容]", "error");
 				return;
 			}
 
 			const path = parsed.content
 				? updatePhaseArtifact(ctx.cwd, run, parsed.phase, parsed.content)
 				: ensurePhaseArtifact(ctx.cwd, run, parsed.phase);
-			ctx.ui.notify(`Artifact ready: ${path}`, "info");
+			ctx.ui.notify(`阶段文档已就绪：${path}`, "info");
 		},
 	});
 
 	pi.registerCommand("kd-answer", {
-		description: "Answer a blocking Kingdee harness question: /kd-answer Q-001 <answer>",
+		description: "回答一个阻塞中的 Kingdee Harness 问题：/kd-answer Q-001 <答案>",
 		handler: async (args, ctx) => {
 			const run = requireRun(ctx.cwd);
 			if (!run) {
-				ctx.ui.notify("No active Kingdee harness run. Use /kd-start <goal>.", "error");
+				ctx.ui.notify("当前没有 active Kingdee Harness run。请使用 /kd-start <需求>。", "error");
 				return;
 			}
 			const [id, ...answerParts] = args.trim().split(/\s+/);
 			const answer = answerParts.join(" ").trim();
 			if (!id || !answer) {
-				ctx.ui.notify("Usage: /kd-answer Q-001 <answer>", "error");
+				ctx.ui.notify("用法：/kd-answer Q-001 <答案>", "error");
 				return;
 			}
 			const answered = answerQuestion(ctx.cwd, run, id, answer);
 			if (!answered) {
-				ctx.ui.notify(`Question not found: ${id}`, "error");
+				ctx.ui.notify(`未找到问题：${id}`, "error");
 				return;
 			}
-			appendQuestionEventToArtifact(ctx.cwd, run, [`- Answered ${answered.id}: ${answered.answer}`]);
-			ctx.ui.notify(`Recorded answer for ${answered.id}`, "info");
+			appendQuestionEventToArtifact(ctx.cwd, run, [`- 已回答 ${answered.id}：${answered.answer}`]);
+			ctx.ui.notify(`已记录 ${answered.id} 的答案`, "info");
 		},
 	});
 }
 
 function formatQuestions(run: NonNullable<ReturnType<typeof readActiveRun>>): string {
 	const questions = run.questions ?? [];
-	if (questions.length === 0) return "No harness questions recorded.";
+	if (questions.length === 0) return "尚未记录 Harness 问题。";
 	return questions.map(formatQuestionCard).join("\n\n");
 }
 
 function formatRuns(runs: NonNullable<ReturnType<typeof readActiveRun>>[], activeId?: string): string {
-	if (runs.length === 0) return "No Kingdee harness runs in this project. Start one with /kd-start <goal>.";
+	if (runs.length === 0) return "当前项目没有 Kingdee Harness run。请使用 /kd-start <需求> 创建。";
 	return runs
 		.map((run) =>
 			[
 				`${run.id === activeId ? "*" : "-"} ${run.id}`,
-				`  Goal: ${run.goal ?? "unknown"}`,
-				`  Status: ${run.status ?? "active"} | Phase: ${run.phase} | Product: ${run.profile?.product ?? run.product ?? "unknown"}`,
-				`  Updated: ${run.updatedAt ?? "unknown"}`,
+				`  需求：${run.goal ?? "未知"}`,
+				`  状态：${run.status ?? "active"} | 阶段：${run.phase} | 产品：${run.profile?.product ?? run.product ?? "unknown"}`,
+				`  更新时间：${run.updatedAt ?? "未知"}`,
 			].join("\n"),
 		)
 		.join("\n\n");
@@ -550,14 +550,14 @@ function formatRuns(runs: NonNullable<ReturnType<typeof readActiveRun>>[], activ
 
 function formatQuestionCard(question: NonNullable<NonNullable<ReturnType<typeof readActiveRun>>["questions"]>[number]): string {
 	const lines = [
-		`Question ${question.id} [${question.status}${question.blocking ? ", blocking" : ""}]`,
-		`Phase: ${question.phase}`,
-		`Question: ${question.question}`,
-		question.reason ? `Reason: ${question.reason}` : undefined,
-		question.choices?.length ? `Choices: ${question.choices.join(" | ")}` : undefined,
-		question.answer ? `Answer: ${question.answer}` : undefined,
+		`问题 ${question.id} [${question.status}${question.blocking ? ", blocking" : ""}]`,
+		`阶段：${question.phase}`,
+		`问题：${question.question}`,
+		question.reason ? `原因：${question.reason}` : undefined,
+		question.choices?.length ? `选项：${question.choices.join(" | ")}` : undefined,
+		question.answer ? `答案：${question.answer}` : undefined,
 		question.status === "open"
-			? `Answer the dialog if available, or reply in chat and record it using kd_question action=answer id=${question.id} answer=<answer>.`
+			? `如果有弹窗，请直接回答；否则请在对话中回复，并用 kd_question action=answer id=${question.id} answer=<答案> 记录。`
 			: undefined,
 	];
 	return lines.filter(Boolean).join("\n");
@@ -589,12 +589,12 @@ async function askQuestionInteractively(
 function questionBatchProblem(question: string, choices?: string[]): string | undefined {
 	const text = question.trim();
 	const numberedItems = text.split(/\r?\n/).filter((line) => /^\s*(\d+[\.\)、)]|[-*]\s+)/.test(line)).length;
-	if (numberedItems >= 2) return "kd_question rejected a batched checklist question.";
-	if ((text.match(/[?？]/g) ?? []).length > 1) return "kd_question rejected multiple questions in one prompt.";
-	if (text.length > 220) return "kd_question rejected an overlong question. Ask only the smallest blocking question first.";
-	if ((choices?.length ?? 0) > 3) return "kd_question rejected too many choices. Provide at most 3 concise choices.";
+	if (numberedItems >= 2) return "kd_question 拒绝了批量清单式问题。";
+	if ((text.match(/[?？]/g) ?? []).length > 1) return "kd_question 拒绝了一次包含多个问题的提问。";
+	if (text.length > 220) return "kd_question 拒绝了过长问题。请只问当前最小的阻塞问题。";
+	if ((choices?.length ?? 0) > 3) return "kd_question 拒绝了过多选项。最多提供 3 个简短选项。";
 	if (choices?.some((choice) => choice.length > 40 || /[\r\n?？]/.test(choice))) {
-		return "kd_question rejected complex choices. Choices must be short labels, not nested questions.";
+		return "kd_question 拒绝了复杂选项。选项必须是短标签，不能嵌套问题。";
 	}
 	return undefined;
 }
@@ -602,14 +602,14 @@ function questionBatchProblem(question: string, choices?: string[]): string | un
 function formatQuestionArtifactLines(question: NonNullable<NonNullable<ReturnType<typeof readActiveRun>>["questions"]>[number]): string[] {
 	return [
 		`- ${question.id} [${question.blocking ? "blocking" : "non-blocking"}] ${question.question}`,
-		question.reason ? `  - Reason: ${question.reason}` : undefined,
-		question.choices?.length ? `  - Choices: ${question.choices.join(" | ")}` : undefined,
-		"  - Status: open",
+		question.reason ? `  - 原因：${question.reason}` : undefined,
+		question.choices?.length ? `  - 选项：${question.choices.join(" | ")}` : undefined,
+		"  - 状态：open",
 	].filter(Boolean) as string[];
 }
 
 function appendQuestionEventToArtifact(cwd: string, run: NonNullable<ReturnType<typeof readActiveRun>>, lines: string[]): void {
 	const existing = readArtifact(cwd, run, run.phase) ?? "";
-	const section = ["", "## Harness Questions", "", ...lines, ""].join("\n");
-	updatePhaseArtifact(cwd, run, run.phase, existing.includes("## Harness Questions") ? `${existing.trimEnd()}\n${lines.join("\n")}\n` : `${existing.trimEnd()}${section}`);
+	const section = ["", "## Harness 问题", "", ...lines, ""].join("\n");
+	updatePhaseArtifact(cwd, run, run.phase, existing.includes("## Harness 问题") ? `${existing.trimEnd()}\n${lines.join("\n")}\n` : `${existing.trimEnd()}${section}`);
 }