@zhushanwen/pi-goal 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-goal",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Codex-style /goal command for Pi — persistent goal-driven autonomous loop with evidence-based completion, token/time budgets, blocked detection, and steering templates.",
   "type": "module",
   "main": "src/index.ts",

package/src/budget.ts

@@ -147,7 +147,7 @@ export function checkProgress(state: GoalRuntimeState, tasksCompletedAtStart: nu
 	return {
 		allTasksDone: totalCount > 0 && incomplete.length === 0 && completedCount > 0,
 		noTasksCreated: totalCount === 0,
-		maxTurnsReached: state.turnCount >= state.budget.maxTurns,
+		maxTurnsReached: state.currentTurnIndex >= state.budget.maxTurns,
 		isStalled: progressThisRound === 0,
 		budgetTight: Boolean(
 			state.budget.tokenBudget &&

package/src/index.ts

@@ -12,7 +12,7 @@
  * 健壮性保障：
  * - goalId snapshot 防止旧回调操作新 goal
  * - 时间累计统一由 persistState 管理，无双写
- * - 防重入保护（hasPendingInjection）
+ * - before_agent_start 注入 context，agent_end 负责 continuation（预算检查/进度评估/续跑）
  * - deserializeState 向后兼容旧格式
  */
 
@@ -150,19 +150,19 @@ async function handleGoalCommand(pi: ExtensionAPI, session: GoalSession, args: s
 	switch (parsed.action) {
 		case "status": {
 			if (!session.state) {
-				ctx.ui.notify("Goal 模式未激活。使用 /goal <objective> 启动。", "info");
+				ctx.ui.notify("Goal mode not active. Use /goal <objective> to start.", "info");
 				return;
 			}
 			const completed = getCompletedCount(session.state.tasks);
 			const total = session.state.tasks.length;
 			const elapsed = getElapsedTimeSeconds(session.state);
 			const lines = [
-				`目标: ${session.state.objective}`,
-				`状态: ${session.state.status}`,
-				`轮次: ${session.state.turnCount}/${session.state.budget.maxTurns}`,
-				`任务: ${completed}/${total} 完成`,
-				`无进展轮数: ${session.state.stallCount}`,
-				`已用时间: ${Math.floor(elapsed / SECONDS_PER_MINUTE)}分${Math.floor(elapsed % SECONDS_PER_MINUTE)}秒`,
+				`Objective: ${session.state.objective}`,
+				`Status: ${session.state.status}`,
+				`Turn: ${session.state.currentTurnIndex}/${session.state.budget.maxTurns}`,
+				`Tasks: ${completed}/${total} completed`,
+				`Stall turns: ${session.state.stallCount}`,
+				`Time elapsed: ${Math.floor(elapsed / SECONDS_PER_MINUTE)}m${Math.floor(elapsed % SECONDS_PER_MINUTE)}s`,
 				session.state.budget.tokenBudget ? `Token: ${session.state.tokensUsed}/${session.state.budget.tokenBudget}` : null,
 				`Goal ID: ${session.state.goalId}`,
 			].filter(Boolean);
@@ -172,31 +172,31 @@ async function handleGoalCommand(pi: ExtensionAPI, session: GoalSession, args: s
 
 		case "pause": {
 			if (!session.state) {
-				ctx.ui.notify("Goal 模式未激活。", "warning");
+				ctx.ui.notify("Goal mode not active.", "warning");
 				return;
 			}
 			if (isTerminalStatus(session.state.status)) {
-				ctx.ui.notify(`Goal 已处于终态 (${session.state.status})，无法暂停。`, "warning");
+				ctx.ui.notify(`Goal is in terminal state (${session.state.status}), cannot pause.`, "warning");
 				return;
 			}
 			session.state.status = transitionStatus(session.state.status, "paused");
 			persistGoalState(pi, session, ctx);
 			updateWidget(session, ctx);
-			ctx.ui.notify("Goal 已暂停。使用 /goal resume 恢复。", "info");
+			ctx.ui.notify("Goal paused. Use /goal resume to continue.", "info");
 			return;
 		}
 
 		case "resume": {
 			if (!session.state) {
-				ctx.ui.notify("Goal 模式未激活。", "warning");
+				ctx.ui.notify("Goal mode not active.", "warning");
 				return;
 			}
 			if (isTerminalStatus(session.state.status)) {
-				ctx.ui.notify(`Goal 已处于终态 (${session.state.status})，无法恢复。`, "warning");
+				ctx.ui.notify(`Goal is in terminal state (${session.state.status}), cannot resume.`, "warning");
 				return;
 			}
 			if (session.state.status !== "paused" && session.state.status !== "blocked") {
-				ctx.ui.notify("Goal 未暂停或阻塞，无需恢复。", "info");
+				ctx.ui.notify("Goal is not paused or blocked, no need to resume.", "info");
 				return;
 			}
 			session.state.status = "active";
@@ -210,7 +210,7 @@ async function handleGoalCommand(pi: ExtensionAPI, session: GoalSession, args: s
 				session.state.status = transitionStatus(session.state.status, dim === "token" ? "budget_limited" : "time_limited");
 				persistGoalState(pi, session, ctx);
 				updateWidget(session, ctx);
-				ctx.ui.notify(`${dim === "token" ? "Token" : "时间"} 预算已耗尽，无法恢复。使用 /goal clear 清除。`, "warning");
+				ctx.ui.notify(`${dim === "token" ? "Token" : "Time"} budget exhausted, cannot resume. Use /goal clear to reset.`, "warning");
 				return;
 			}
 
@@ -220,17 +220,17 @@ async function handleGoalCommand(pi: ExtensionAPI, session: GoalSession, args: s
 			const incomplete = getIncompleteTasks(session.state.tasks);
 			if (incomplete.length > 0) {
 				pi.sendUserMessage(
-					`Goal 已恢复。继续执行剩余 ${incomplete.length} 个任务。` +
+					`Goal resumed. Continuing with ${incomplete.length} remaining tasks.` +
 					(session.state.lastBlockerReason ? `
 
-上次阻塞原因: ${session.state.lastBlockerReason}。请尝试不同的方法。` : "") +
+Previous blocker: ${session.state.lastBlockerReason}. Try a different approach.` : "") +
 					`
 
-目标: ${session.state.objective}`,
+Objective: ${session.state.objective}`,
 					{ deliverAs: "followUp" },
 				);
 			} else {
-				ctx.ui.notify("所有任务已完成。", "info");
+				ctx.ui.notify("All tasks completed.", "info");
 			}
 			return;
 		}
@@ -250,13 +250,13 @@ async function handleGoalCommand(pi: ExtensionAPI, session: GoalSession, args: s
 			}>>;
 
 			if (historyEntries.length === 0) {
-				ctx.ui.notify("暂无历史 Goal", "info");
+				ctx.ui.notify("No goal history", "info");
 				return;
 			}
 
 			// 按时间倒序
 			const sorted = [...historyEntries].reverse();
-			const lines: string[] = ["历史 Goal：\n"];
+			const lines: string[] = ["Goal history:\n"];
 			for (let i = 0; i < sorted.length; i++) {
 				const h = sorted[i]!.data;
 				if (!h) continue;
@@ -271,7 +271,7 @@ async function handleGoalCommand(pi: ExtensionAPI, session: GoalSession, args: s
 				const mins = Math.floor(h.elapsedSeconds / SECONDS_PER_MINUTE);
 				const secs = Math.floor(h.elapsedSeconds % SECONDS_PER_MINUTE);
 				lines.push(`${i + 1}. ${statusIcon} ${objDisplay}`);
-				lines.push(`   ${h.completedTasks}/${h.totalTasks} 任务 | ${mins}分${secs}秒 | ${h.status}`);
+				lines.push(`   ${h.completedTasks}/${h.totalTasks} tasks | ${mins}m${secs}s | ${h.status}`);
 			}
 			ctx.ui.notify(lines.join("\n"), "info");
 			return;
@@ -279,7 +279,7 @@ async function handleGoalCommand(pi: ExtensionAPI, session: GoalSession, args: s
 
 		case "clear": {
 			if (!session.state) {
-				ctx.ui.notify("Goal 模式未激活。", "info");
+				ctx.ui.notify("Goal mode not active.", "info");
 				return;
 			}
 			session.state.status = "cancelled";
@@ -287,17 +287,17 @@ async function handleGoalCommand(pi: ExtensionAPI, session: GoalSession, args: s
 			writeGoalHistoryEntry(pi, session);
 			persistGoalState(pi, session, ctx);
 			clearGoalSession(session, ctx);
-			ctx.ui.notify("Goal 已清除。", "info");
+			ctx.ui.notify("Goal cleared.", "info");
 			return;
 		}
 
 		case "update": {
 			if (!session.state) {
-				ctx.ui.notify("Goal 模式未激活。", "warning");
+				ctx.ui.notify("Goal mode not active.", "warning");
 				return;
 			}
 			if (!parsed.objective) {
-				ctx.ui.notify("用法: /goal update <new-objective>", "warning");
+				ctx.ui.notify("Usage: /goal update <new-objective>", "warning");
 				return;
 			}
 			const oldObjective = session.state.objective;
@@ -306,6 +306,7 @@ async function handleGoalCommand(pi: ExtensionAPI, session: GoalSession, args: s
 			session.state.tasks = [];
 			session.state.stallCount = 0;
 			session.state.turnCount = 0;
+			session.state.currentTurnIndex = 0;
 			session.state.lastProgressTurn = 0;
 			session.state.budgetLimitSteeringSent = false;
 			session.state.budgetWarning70Sent = false;
@@ -313,7 +314,7 @@ async function handleGoalCommand(pi: ExtensionAPI, session: GoalSession, args: s
 			session.tasksCompletedAtAgentStart = 0;
 			persistGoalState(pi, session, ctx);
 			updateWidget(session, ctx);
-			ctx.ui.notify(`目标已更新:\n旧: ${oldObjective}\n新: ${parsed.objective}`, "info");
+			ctx.ui.notify(`Objective updated:\nPrevious: ${oldObjective}\nNew: ${parsed.objective}`, "info");
 
 			if (isActiveStatus(session.state.status)) {
 				pi.sendUserMessage(objectiveUpdatedPrompt(session.state, oldObjective), { deliverAs: "steer" });
@@ -323,16 +324,16 @@ async function handleGoalCommand(pi: ExtensionAPI, session: GoalSession, args: s
 
 		case "set": {
 			if (!parsed.objective) {
-				ctx.ui.notify("用法: /goal <objective> [--tokens N] [--timeout N]", "warning");
+				ctx.ui.notify("Usage: /goal <objective> [--tokens N] [--timeout N]", "warning");
 				return;
 			}
 			if (!parsed.objective.trim()) {
-				ctx.ui.notify("目标描述不能为空。", "warning");
+				ctx.ui.notify("Objective cannot be empty.", "warning");
 				return;
 			}
 			if (session.state && !isTerminalStatus(session.state.status)) {
 				ctx.ui.notify(
-					`已取消旧 Goal: ${session.state.objective}\n(新目标已启动)`,
+					`Cancelled previous Goal: ${session.state.objective}\n(new goal started)`,
 					"info",
 				);
 				session.state.status = "cancelled";
@@ -342,7 +343,7 @@ async function handleGoalCommand(pi: ExtensionAPI, session: GoalSession, args: s
 			}
 
 			if (parsed.budget?.tokenBudget !== undefined && parsed.budget.tokenBudget <= 0) {
-				ctx.ui.notify("Token 预算必须大于 0。", "warning");
+				ctx.ui.notify("Token budget must be greater than 0.", "warning");
 				return;
 			}
 			const budget: Partial<BudgetConfig> = {};
@@ -359,11 +360,11 @@ async function handleGoalCommand(pi: ExtensionAPI, session: GoalSession, args: s
 			updateWidget(session, ctx);
 
 			const budgetNotice: string[] = [];
-			if (budget.tokenBudget) budgetNotice.push(`Token 预算: ${budget.tokenBudget}`);
-			if (budget.timeBudgetMinutes) budgetNotice.push(`时间预算: ${budget.timeBudgetMinutes} 分钟`);
+			if (budget.tokenBudget) budgetNotice.push(`Token budget: ${budget.tokenBudget}`);
+			if (budget.timeBudgetMinutes) budgetNotice.push(`Time budget: ${budget.timeBudgetMinutes} min`);
 			const notice = [
-				`Goal 已启动: ${parsed.objective}`,
-				`最大轮次: ${budget.maxTurns}`,
+				`Goal started: ${parsed.objective}`,
+				`Max turns: ${budget.maxTurns}`,
 				...budgetNotice,
 			].join("\n");
 			ctx.ui.notify(notice, "info");
@@ -477,11 +478,11 @@ async function handleBeforeAgentStart(pi: ExtensionAPI, session: GoalSession, ct
 			message: {
 				customType: "goal-context-exceeded",
 				content:
-					"[GOAL — 上下文空间不足，必须立即收尾]\n" +
-					"1. 用 goal_manager 的 list_tasks 查看剩余任务\n" +
-					"2. 只标记你真正完成且有证据的任务\n" +
-					"3. 总结当前进度和剩余工作\n" +
-					"不要再开始新任务。",
+					"[GOAL — context space low, must wrap up now]\n" +
+					"1. Use goal_manager's list_tasks to check remaining tasks\n" +
+					"2. Only mark tasks you genuinely completed with evidence\n" +
+					"3. Summarize current progress and remaining work\n" +
+					"Do not start new tasks.",
 				display: false,
 			},
 		};
@@ -510,7 +511,7 @@ async function handleAgentEnd(pi: ExtensionAPI, session: GoalSession, ctx: Exten
 		if (checkStale()) return;
 		updateWidget(session, ctx);
 		ctx.ui.notify(
-			`目标已完成 ✓ (${getCompletedCount(session.state.tasks)}/${session.state.tasks.length} 任务, ${session.state.turnCount} 轮)`,
+			`Objective completed ✓ (${getCompletedCount(session.state.tasks)}/${session.state.tasks.length} tasks, ${session.state.currentTurnIndex} turns)`,
 			"info",
 		);
 		return;
@@ -520,18 +521,12 @@ async function handleAgentEnd(pi: ExtensionAPI, session: GoalSession, ctx: Exten
 		persistGoalState(pi, session, ctx);
 		if (checkStale()) return;
 		updateWidget(session, ctx);
-		ctx.ui.notify("Goal 被阻塞。使用 /goal resume 恢复或 /goal clear 清除。", "warning");
+		ctx.ui.notify("Goal blocked. Use /goal resume to continue or /goal clear to reset.", "warning");
 		return;
 	}
 
 	if (!isActiveStatus(session.state.status)) return;
 
-	// 防重入
-	if (session.hasPendingInjection) {
-		session.hasPendingInjection = false;
-		return;
-	}
-
 	if (checkStale()) return;
 
 	// ── 预算策略（集中检查）──
@@ -542,10 +537,10 @@ async function handleAgentEnd(pi: ExtensionAPI, session: GoalSession, ctx: Exten
 	for (const w of budgetResult.warnings) {
 		if (w.type === "warning90") {
 			session.state.budgetWarning90Sent = true;
-			ctx.ui.notify(`${w.dimension === "token" ? "Token" : "时间"} 预算已用 90%，请开始收尾。`, "warning");
+			ctx.ui.notify(`${w.dimension === "token" ? "Token" : "Time"} budget 90% used — start wrapping up.`, "warning");
 		} else if (w.type === "warning70") {
 			session.state.budgetWarning70Sent = true;
-			ctx.ui.notify(`${w.dimension === "token" ? "Token" : "时间"} 预算已用 70%，注意控制范围。`, "info");
+			ctx.ui.notify(`${w.dimension === "token" ? "Token" : "Time"} budget 70% used — keep scope in check.`, "info");
 		}
 	}
 
@@ -560,8 +555,8 @@ async function handleAgentEnd(pi: ExtensionAPI, session: GoalSession, ctx: Exten
 		updateWidget(session, ctx);
 		ctx.ui.notify(
 			dim === "token"
-				? "Token 预算已耗尽，Goal 已终止。"
-				: `时间预算耗尽 (${session.state.budget.timeBudgetMinutes} 分钟)，Goal 已终止。`,
+				? "Token budget exhausted, Goal terminated."
+				: `Time budget exhausted (${session.state.budget.timeBudgetMinutes} min), Goal terminated.`,
 			"warning",
 		);
 		return;
@@ -595,7 +590,7 @@ async function handleAgentEnd(pi: ExtensionAPI, session: GoalSession, ctx: Exten
 			if (checkStale()) return;
 			updateWidget(session, ctx);
 			ctx.ui.notify(
-				`所有任务已完成，Goal 自动结束。(${progress.completedCount}/${progress.totalCount} 任务, ${session.state.turnCount} 轮)`,
+				`All tasks completed, Goal auto-closed. (${progress.completedCount}/${progress.totalCount} tasks, ${session.state.currentTurnIndex} turns)`,
 				"info",
 			);
 			return;
@@ -603,15 +598,15 @@ async function handleAgentEnd(pi: ExtensionAPI, session: GoalSession, ctx: Exten
 
 		if (progress.budgetTight) {
 			pi.sendUserMessage(
-				`所有任务已完成，且 token 预算已用 ${Math.round(session.state.tokensUsed / session.state.budget.tokenBudget! * PERCENT_FACTOR)}%。` +
-				`请立即调用 goal_manager 的 complete_goal 完成目标，提供整体 evidence。` +
-				`\n\n目标: ${session.state.objective}`,
+				`All tasks completed, token budget ${Math.round(session.state.tokensUsed / session.state.budget.tokenBudget! * PERCENT_FACTOR)}% used.` +
+				`Call goal_manager's complete_goal now with overall evidence.` +
+				`\n\nObjective: ${session.state.objective}`,
 				{ deliverAs: "steer" },
 			);
 		} else {
 			pi.sendUserMessage(
-				`所有 ${progress.totalCount} 个任务已完成。请调用 goal_manager 的 complete_goal 完成目标，提供整体 evidence。` +
-					`\n\n目标: ${session.state.objective}`,
+				`All ${progress.totalCount} tasks completed. Call goal_manager's complete_goal with overall evidence.` +
+					`\n\nObjective: ${session.state.objective}`,
 				{ deliverAs: "followUp" },
 			);
 		}
@@ -630,14 +625,14 @@ async function handleAgentEnd(pi: ExtensionAPI, session: GoalSession, ctx: Exten
 			if (checkStale()) return;
 			updateWidget(session, ctx);
 			ctx.ui.notify(
-				`已达最大轮次 (${session.state.budget.maxTurns})，LLM 未创建任务清单。`,
+				`Max turns reached (${session.state.budget.maxTurns}), LLM did not create task list.`,
 				"warning",
 			);
 			return;
 		}
 		pi.sendUserMessage(
-			`你尚未创建任务清单。请立即调用 goal_manager 的 create_tasks 将工作拆分为具体可验证的任务步骤。` +
-				`\n\n目标: ${session.state.objective}`,
+			`No task list created yet. Call goal_manager's create_tasks immediately to decompose the work into verifiable task steps.` +
+				`\n\nObjective: ${session.state.objective}`,
 			{ deliverAs: "followUp" },
 		);
 		persistGoalState(pi, session, ctx);
@@ -655,7 +650,7 @@ async function handleAgentEnd(pi: ExtensionAPI, session: GoalSession, ctx: Exten
 		if (checkStale()) return;
 		updateWidget(session, ctx);
 		ctx.ui.notify(
-			`已达最大轮次 (${session.state.budget.maxTurns})，还有 ${incomplete.length} 个任务未完成。`,
+			`Max turns reached (${session.state.budget.maxTurns}), ${incomplete.length} tasks still incomplete.`,
 			"warning",
 		);
 		return;
@@ -666,7 +661,7 @@ async function handleAgentEnd(pi: ExtensionAPI, session: GoalSession, ctx: Exten
 		session.state.stallCount++;
 	} else {
 		session.state.stallCount = 0;
-		session.state.lastProgressTurn = session.state.turnCount;
+		session.state.lastProgressTurn = session.state.currentTurnIndex;
 	}
 
 	if (session.state.stallCount >= session.state.budget.maxStallTurns) {
@@ -675,7 +670,7 @@ async function handleAgentEnd(pi: ExtensionAPI, session: GoalSession, ctx: Exten
 		if (checkStale()) return;
 		updateWidget(session, ctx);
 		ctx.ui.notify(
-			`已连续 ${session.state.stallCount} 轮无进展，Goal 自动阻塞。使用 /goal resume 恢复或 /goal clear 清除。`,
+			`${session.state.stallCount} consecutive turns without progress, Goal auto-blocked. Use /goal resume to continue or /goal clear to reset.`,
 			"warning",
 		);
 		return;
@@ -715,33 +710,33 @@ export default function goalExtension(pi: ExtensionAPI) {
 		name: "goal_manager",
 		label: "Goal Manager",
 		description:
-			"Goal 模式任务管理器。此工具仅在用户通过 /goal 命令启动目标后才可用，AI 不能主动触发此功能。如果 Goal 模式未激活，调用此工具会报错。" +
-			"\n\n可用 action:" +
-			"\n- create_tasks: 首次拆分目标为任务清单（每个 goal 开始时调用一次）。每条 task description 必须是一行简短摘要（不超过 60 字），不要包含换行、markdown、详细参数" +
-			"\n- add_tasks: 向已有任务清单追加新任务（执行中发现遗漏时使用）。每条 task description 必须是一行简短摘要（不超过 60 字），不要包含换行、markdown、详细参数" +
-			"\n- update_tasks: 批量更新任务状态（completed 必须带 evidence，cancelled 不阻碍 goal 完成）" +
-			"\n- list_tasks: 查看进度和剩余预算" +
-			"\n- complete_goal: 标记目标达成（必须所有任务完成 + evidence）" +
-			"\n- cancel_goal: 取消当前目标（用户要求退出/停止时使用）" +
-			"\n- report_blocked: 报告阻塞（遇到无法解决的问题时使用）" +
-			"\n- add_subtasks: 给指定 task 添加 subtask（参数: taskId, texts[]）。Goal 模式下用此替代 todo 工具" +
-			"\n- update_subtasks: 批量更新 subtask 状态（参数: taskId, subUpdates[]）" +
-			"\n- delete_subtasks: 删除指定 task 的 subtask（参数: taskId, subIds[]）",
-		promptSnippet: "管理 /goal 模式的任务清单、完成状态和退出",
+			"Goal mode task manager. This tool is only available after starting a goal via the /goal command. AI cannot trigger it proactively. If Goal mode is not active, calling this tool will error." +
+			"\n\nAvailable actions:" +
+			"\n- create_tasks: Decompose the objective into a task list (call once at goal start). Each task description must be a one-line summary (max 60 chars), no newlines or markdown" +
+			"\n- add_tasks: Append new tasks to the existing list (when omissions are discovered). Each task description must be a one-line summary (max 60 chars), no newlines or markdown" +
+			"\n- update_tasks: Batch update task statuses (completed requires evidence, cancelled does not block goal completion)" +
+			"\n- list_tasks: View progress and remaining budget" +
+			"\n- complete_goal: Mark the objective as achieved (all tasks must be completed + evidence)" +
+			"\n- cancel_goal: Cancel the current goal (use when user wants to exit/stop)" +
+			"\n- report_blocked: Report being blocked (use when encountering unsolvable issues)" +
+			"\n- add_subtasks: Add subtasks to a specified task (params: taskId, texts[]). Use this instead of todo tool in Goal mode" +
+			"\n- update_subtasks: Batch update subtask statuses (params: taskId, subUpdates[])" +
+			"\n- delete_subtasks: Delete subtasks from a specified task (params: taskId, subIds[])",
+		promptSnippet: "Manage task list, completion status, and exit for /goal mode",
 		promptGuidelines: [
-			"[工作流] 收到目标后，第一步必须调用 create_tasks 拆分任务。已有任务清单时不要重复调用",
-			"[格式] 每个 task description 必须是一行简短摘要，不超过 60 个字符。不要包含换行符、markdown 格式、详细参数列表——这些放在执行阶段处理。示例: '修复 hook-registry 去重逻辑' 而不是 '修复 hook-registry 去重逻辑 + transport-execute enhancementConfig 防护 + failover-loop ...'",
-			"[追加] 执行中发现遗漏的子任务时，使用 add_tasks 追加，不要尝试重新 create_tasks",
-			"[完成] 每完成一个任务调用 update_tasks 将状态设为 completed，必须提供 evidence（具体证据，如'测试 X 通过'、'文件 F 已创建'）",
-			"[目标完成] 只有所有任务完成且有整体证据时，才能调用 complete_goal",
-			"[退出] 当用户说'停止'、'退出'、'取消'、'stop'、'exit'、'cancel'、'不用了'、'结束'等表示不想继续时，立即调用 cancel_goal 取消目标，不要引导用户走 complete_goal 流程",
-			"[阻塞] 遇到无法解决的技术问题时调用 report_blocked 说明原因",
-			"[进度] 随时可用 list_tasks 查看剩余任务和预算，",
-			"[取消] 取消任务时使用 update_tasks 将状态设为 cancelled，取消的任务不阻碍 goal 完成",
-			"[禁止] 不要在没有 evidence 的情况下将任务标记为 completed，也不要在没有 evidence 时调用 complete_goal",
-			"[禁止] 不要在用户明确想退出时强制要求完成任务——直接 cancel_goal",
-			"[禁止] 不要重复调用 create_tasks 覆盖已有未完成任务，如需追加请用 add_tasks",
-			"[subtask] Goal 模式下需要细粒度步骤追踪时，使用 add_subtasks 给 task 添加 subtask，不要使用 todo 工具",
+			"[Workflow] After receiving the objective, the first step must be create_tasks to decompose. Do not re-call if task list already exists",
+			"[Format] Each task description must be a one-line summary, max 60 chars. No newlines, markdown, or detailed parameter lists — those go in execution phase. Example: 'Fix hook-registry dedup logic' not 'Fix hook-registry dedup + transport-execute enhancementConfig guard + failover-loop ...'",
+			"[Append] When discovering omissions during execution, use add_tasks to append — do not re-call create_tasks",
+			"[Completion] After completing a task, call update_tasks with status=completed and provide evidence (e.g. 'test X passed', 'file F created')",
+			"[Goal completion] Only call complete_goal when all tasks are completed with overall evidence",
+			"[Exit] When user says 'stop', 'exit', 'cancel', '不用了', '结束', etc. indicating they don't want to continue, immediately call cancel_goal — do not guide them through complete_goal",
+			"[Blocked] When encountering unsolvable technical issues, call report_blocked with the reason",
+			"[Progress] Use list_tasks anytime to check remaining tasks and budget",
+			"[Cancel] To cancel a task, use update_tasks with status=cancelled. Cancelled tasks do not block goal completion",
+			"[Forbidden] Do not mark tasks as completed without evidence, and do not call complete_goal without evidence",
+			"[Forbidden] Do not force task completion when the user explicitly wants to exit — call cancel_goal directly",
+			"[Forbidden] Do not re-call create_tasks to overwrite existing incomplete tasks — use add_tasks to append",
+			"[Subtask] For fine-grained step tracking in Goal mode, use add_subtasks — do not use the todo tool",
 		],
 		parameters: GoalManagerParams,
 
@@ -777,7 +772,7 @@ export default function goalExtension(pi: ExtensionAPI) {
 			}
 			const tasks = details.tasks;
 			const completed = tasks.filter((t) => t.status === "completed").length;
-			const summary = theme.fg("success", `✓ ${completed}/${tasks.length} 完成`);
+			const summary = theme.fg("success", `✓ ${completed}/${tasks.length} completed`);
 			if (!expanded || tasks.length === 0) {
 				return new Text(summary, 0, 0);
 			}
@@ -816,7 +811,7 @@ export default function goalExtension(pi: ExtensionAPI) {
 
 	pi.registerCommand("goal", {
 		description:
-			"目标驱动模式: /goal <objective> [--tokens N] [--timeout N] [--max-turns N] | /goal pause | /goal resume | /goal clear | /goal update <new-objective> | /goal status | /goal history",
+			"Goal-driven mode: /goal <objective> [--tokens N] [--timeout N] [--max-turns N] | /goal pause | /goal resume | /goal clear | /goal update <new-objective> | /goal status | /goal history",
 		handler: async (args: string | undefined, ctx: ExtensionCommandContext) => {
 			await handleGoalCommand(pi, session, args, ctx);
 		},
@@ -890,9 +885,9 @@ export default function goalExtension(pi: ExtensionAPI) {
 		pi.registerMessageRenderer(customType, (message: any, _options: any, theme: Theme) => {
 			const prefix =
 				message.customType === "goal-context-exceeded"
-					? theme.fg("error", "[GOAL 预算] ")
+					? theme.fg("error", "[GOAL Budget] ")
 					: message.customType === "goal-staleness-reminder"
-						? theme.fg("warning", "[GOAL 提醒] ")
+						? theme.fg("warning", "[GOAL Reminder] ")
 						: theme.fg("accent", "[GOAL] ");
 			const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
 			return new Text(prefix + theme.fg("dim", content), 0, 0);

package/src/templates.ts

@@ -33,20 +33,20 @@ export function continuationPrompt(state: GoalRuntimeState): string {
 
 	// Budget info (single line, Codex style)
 	const budgetLine = formatBudgetLine(state);
-	const stallLine = state.stallCount > 0 ? `\nStall: ${state.stallCount}/${state.budget.maxStallTurns}轮无进展` : "";
+	const stallLine = state.stallCount > 0 ? `\nStall: ${state.stallCount}/${state.budget.maxStallTurns} turns stalled` : "";
 
 	// Task summary (only IDs, not full descriptions — descriptions in before_agent_start)
 	const taskLine = total > 0
-		? `Tasks: ${completedCount}/${total}${incomplete.length > 0 ? ` (剩余: ${incomplete.map(t => `#${t.id}`).join(",")})` : " ✓"}`
-		: "Tasks: 未创建。请立即 create_tasks。";
+		? `Tasks: ${completedCount}/${total}${incomplete.length > 0 ? ` (remaining: ${incomplete.map(t => `#${t.id}`).join(",")})` : " ✓"}`
+		: "Tasks: Not created. Call create_tasks immediately.";
 
 	return (
 		`<goal_context>\n` +
-		`[GOAL] Turn ${state.turnCount}/${state.budget.maxTurns}${budgetLine}${stallLine}\n` +
+		`[GOAL] Turn ${state.currentTurnIndex}/${state.budget.maxTurns}${budgetLine}${stallLine}\n` +
 		`<objective>${objective}</objective>\n` +
 		`${taskLine}\n` +
-		`Rules: create_tasks→update_tasks(evidence)→complete_goal(evidence). blocked→report_blocked(reason). subtask: add_subtasks/update_subtasks (替代 todo 工具).\n` +
-		`Audit: 逐项验证每个需求有权威证据。不因预算耗尽标记完成，不因困难标记阻塞。\n` +
+		`Rules: create_tasks→update_tasks(evidence)→complete_goal(evidence). blocked→report_blocked(reason). subtask: add_subtasks/update_subtasks (replaces todo tool).\n` +
+		`Audit: Verify each requirement has authoritative evidence. Do not mark completed due to budget exhaustion, do not mark blocked due to difficulty.\n` +
 		`</goal_context>`
 	);
 }
@@ -62,24 +62,24 @@ export function budgetLimitPrompt(state: GoalRuntimeState, limitType: "token" |
 	const incomplete = getIncompleteTasks(state.tasks);
 	const incompleteSummary =
 		incomplete.length > 0
-			? `未完成: ${incomplete.map((t) => `#${t.id}`).join(", ")}`
-			: "所有任务已完成。";
+			? `Incomplete: ${incomplete.map((t) => `#${t.id}`).join(", ")}`
+			: "All tasks completed.";
 
 	return (
 		`<goal_context>\n` +
-		`[GOAL — ${limitType === "token" ? "TOKEN 预算" : "时间预算"}即将耗尽]\n\n` +
+		`[GOAL — ${limitType === "token" ? "TOKEN budget" : "time budget"} almost exhausted]\n\n` +
 		`<objective>\n${objective}\n</objective>\n\n` +
-		`当前进度: ${completedCount}/${total} 任务完成\n` +
+		`Current progress: ${completedCount}/${total} tasks completed\n` +
 		`${incompleteSummary}\n` +
 		(limitType === "token"
-			? `Token 已使用: ${state.tokensUsed} / ${state.budget.tokenBudget ?? "未知"}\n`
-			: `已用时间: ${Math.floor(elapsed / SECONDS_PER_MINUTE)}分${Math.floor(elapsed % SECONDS_PER_MINUTE)}秒 / ${state.budget.timeBudgetMinutes ?? "未知"}分钟\n`) +
-		`\n你必须立即收尾:\n` +
-		`1. 用 goal_manager 的 list_tasks 查看剩余任务\n` +
-		`2. 只标记你真正完成且有证据的任务\n` +
-		`3. 如果目标已达成，调用 goal_manager 的 complete_goal 完成目标\n` +
-		`4. 总结当前进度和剩余工作\n` +
-		`不要再开始新任务。不要因为预算耗尽就标记完成。\n` +
+			? `Tokens used: ${state.tokensUsed} / ${state.budget.tokenBudget ?? "unknown"}\n`
+			: `Time elapsed: ${Math.floor(elapsed / SECONDS_PER_MINUTE)}m${Math.floor(elapsed % SECONDS_PER_MINUTE)}s / ${state.budget.timeBudgetMinutes ?? "unknown"} min\n`) +
+		`\nYou must wrap up immediately:\n` +
+		`1. Use goal_manager's list_tasks to check remaining tasks\n` +
+		`2. Only mark tasks you have genuinely completed with evidence\n` +
+		`3. If the objective is met, call goal_manager's complete_goal\n` +
+		`4. Summarize current progress and remaining work\n` +
+		`Do not start new tasks. Do not mark completed due to budget exhaustion.\n` +
 		`</goal_context>`
 	);
 }
@@ -92,14 +92,14 @@ export function objectiveUpdatedPrompt(state: GoalRuntimeState, oldObjective: st
 
 	return (
 		`<goal_context>\n` +
-		`[GOAL — 目标已更新]\n\n` +
-		`旧目标: ${escapedOld}\n` +
+		`[GOAL — Objective updated]\n\n` +
+		`Previous objective: ${escapedOld}\n` +
 		`<untrusted_objective>\n${newObjective}\n</untrusted_objective>\n\n` +
-		`这个新目标取代了之前的所有目标上下文。你需要:\n` +
-		`1. 立即停止朝旧目标方向的工作\n` +
-		`2. 重新评估任务清单，必要时调用 goal_manager 的 create_tasks 重新拆分\n` +
-		`3. 只在旧目标的工作也对新目标有帮助时才继续\n` +
-		`4. 按照新目标继续工作\n` +
+		`This new objective supersedes all prior objective context. You must:\n` +
+		`1. Immediately stop working toward the old objective\n` +
+		`2. Re-evaluate the task list — call goal_manager's create_tasks to re-decompose if needed\n` +
+		`3. Only continue old work if it also serves the new objective\n` +
+		`4. Proceed with the new objective\n` +
 		`</goal_context>`
 	);
 }
@@ -114,17 +114,17 @@ export function contextInjectionPrompt(state: GoalRuntimeState): string {
 
 	return (
 		`<goal_context>\n` +
-		`[GOAL 模式已激活]\n\n` +
+		`[GOAL mode activated]\n\n` +
 		`<objective>\n${objective}\n</objective>\n` +
-		`状态: ${state.status}\n` +
-		`轮次: ${state.turnCount}/${state.budget.maxTurns}${budgetInfo}\n` +
-		`任务进度: ${completedCount}/${total}\n\n` +
-		`严格规则:\n` +
-		`1. 第一步必须调用 goal_manager 的 create_tasks 拆分任务（如果尚未创建）\n` +
-		`2. 每完成一个任务调用 update_tasks 将状态设为 completed，并提供 evidence\n` +
-		`3. 只有提供具体证据时才能调用 complete_goal\n` +
-		`4. 遇到阻塞调用 report_blocked\n` +
-		`5. Goal 模式下不要使用 todo 工具，使用 add_subtasks / update_subtasks 追踪细粒度步骤\n` +
+		`Status: ${state.status}\n` +
+		`Turn: ${state.currentTurnIndex}/${state.budget.maxTurns}${budgetInfo}\n` +
+		`Task progress: ${completedCount}/${total}\n\n` +
+		`Strict rules:\n` +
+		`1. First step: call goal_manager's create_tasks to decompose tasks (if not yet created)\n` +
+		`2. After completing a task, call update_tasks with status=completed and provide evidence\n` +
+		`3. Only call complete_goal with concrete evidence\n` +
+		`4. If blocked, call report_blocked\n` +
+		`5. In Goal mode, do not use the todo tool — use add_subtasks / update_subtasks for fine-grained tracking\n` +
 		`</goal_context>`
 	);
 }
@@ -144,23 +144,23 @@ export function stalenessReminderPrompt(
 	const lines: string[] = [];
 
 	lines.push("<goal_context>");
-	lines.push("[GOAL 提醒 — 有任务停滞]\n");
+	lines.push("[GOAL reminder — tasks stalled]\n");
 
 	if (allTerminal) {
-		lines.push("所有任务已完成，但 goal_manager 未关闭。请调用 complete_goal 或 cancel_goal。");
+		lines.push("All tasks completed but goal_manager is still open. Call complete_goal or cancel_goal.");
 	} else {
-		lines.push(`以下任务已超过 ${TASK_STALL_TURN_THRESHOLD} turn 未更新：\n`);
+		lines.push(`The following tasks have exceeded ${TASK_STALL_TURN_THRESHOLD} turns without update:\n`);
 		for (const item of staleTasks) {
-			lines.push(`  #${item.task.id}: ${item.task.description} (${item.staleTurns} turn 未操作)`);
+			lines.push(`  #${item.task.id}: ${item.task.description} (${item.staleTurns} turns idle)`);
 			for (const s of item.staleSubtasks) {
-				lines.push(`    - ${s.text} (${s.staleTurns} turn)`);
+				lines.push(`    - ${s.text} (${s.staleTurns} turns)`);
 			}
 		}
-		lines.push("\n请检查这些任务的状态，调用 update_tasks 更新进展或 cancel 不再需要的任务。");
+		lines.push("\nCheck these tasks — call update_tasks to report progress or cancel tasks that are no longer needed.");
 	}
 
-	lines.push(`\n目标: ${objective}`);
-	lines.push(`Turn: ${state.turnCount}/${state.budget.maxTurns}`);
+	lines.push(`\nObjective: ${objective}`);
+	lines.push(`Turn: ${state.currentTurnIndex}/${state.budget.maxTurns}`);
 	lines.push("</goal_context>");
 
 	return lines.join("\n");
@@ -177,7 +177,7 @@ function formatBudgetInfo(state: GoalRuntimeState): string {
 	if (state.budget.timeBudgetMinutes) {
 		const elapsed = getElapsedTimeSeconds(state);
 		const pct = Math.round((elapsed / (state.budget.timeBudgetMinutes * SECONDS_PER_MINUTE)) * PERCENT_FACTOR);
-		parts.push(`时间: ${pct}%`);
+		parts.push(`Time: ${pct}%`);
 	}
 	return parts.length > 0 ? ` (${parts.join(", ")})` : "";
 }
@@ -197,13 +197,13 @@ function formatBudgetLine(state: GoalRuntimeState): string {
 }
 
 export function formatTaskList(tasks: GoalTask[]): string {
-	if (tasks.length === 0) return "暂无任务。";
+	if (tasks.length === 0) return "No tasks yet.";
 	const completed = tasks.filter(t => t.status === "completed");
 	const active = tasks.filter(t => t.status === "in_progress" || t.status === "pending");
 	const cancelled = tasks.filter(t => t.status === "cancelled");
 	const lines: string[] = [];
 	if (active.length > 0) {
-		lines.push(`进行中/待执行 (${active.length}):`);
+		lines.push(`In progress / Pending (${active.length}):`);
 		for (const t of active) {
 			const icon = t.status === "in_progress" ? "●" : "☐";
 			lines.push(`  ${icon} #${t.id}: ${t.description}`);
@@ -216,17 +216,17 @@ export function formatTaskList(tasks: GoalTask[]): string {
 		}
 	}
 	if (completed.length > 0) {
-		lines.push(`已完成 (${completed.length}):`);
+		lines.push(`Completed (${completed.length}):`);
 		for (const t of completed) {
 			const evidence = t.evidence ? ` — ${t.evidence}` : "";
 			lines.push(`  ✓ #${t.id}: ${t.description}${evidence}`);
 		}
 	}
 	if (cancelled.length > 0) {
-		lines.push(`已取消 (${cancelled.length}):`);
+		lines.push(`Cancelled (${cancelled.length}):`);
 		for (const t of cancelled) lines.push(`  ✗ #${t.id}: ${t.description}`);
 	}
-	const summary = `${completed.length}/${tasks.length} 完成` + (cancelled.length > 0 ? `, ${cancelled.length} 已取消` : "");
+	const summary = `${completed.length}/${tasks.length} completed` + (cancelled.length > 0 ? `, ${cancelled.length} cancelled` : "");
 	lines.push(summary);
 	return lines.join("\n");
 }

package/src/tool-handler.ts

@@ -61,19 +61,19 @@ export const GoalManagerParams = Type.Object({
 		"update_subtasks",
 		"delete_subtasks",
 	] as const),
-	tasks: Type.Optional(Type.Array(Type.String(), { description: "Task descriptions. 每条必须是一行简短摘要（不超过 60 字），不含换行或 markdown" })),
+	tasks: Type.Optional(Type.Array(Type.String(), { description: "Task descriptions. Each must be a one-line summary (max 60 chars), no newlines or markdown" })),
 	updates: Type.Optional(Type.Array(Type.Object({
 		taskId: Type.Number(),
 		status: StringEnum(GOAL_TASK_STATUSES),
 		evidence: Type.Optional(Type.String()),
 	}))),
-	taskId: Type.Optional(Type.Number({ description: "Task ID（subtask 操作时必需）" })),
-	texts: Type.Optional(Type.Array(Type.String(), { description: "Subtask 文本列表（add_subtasks 时使用）" })),
+	taskId: Type.Optional(Type.Number({ description: "Task ID (required for subtask operations)" })),
+	texts: Type.Optional(Type.Array(Type.String(), { description: "Subtask text list (for add_subtasks)" })),
 	subUpdates: Type.Optional(Type.Array(Type.Object({
 		subId: Type.Number(),
 		status: StringEnum(SUBTASK_STATUSES),
 	}))),
-	subIds: Type.Optional(Type.Array(Type.Number(), { description: "Subtask ID 列表（delete_subtasks 时使用）" })),
+	subIds: Type.Optional(Type.Array(Type.Number(), { description: "Subtask ID list (for delete_subtasks)" })),
 	evidence: Type.Optional(Type.String({ description: "Evidence for completion (required for complete_goal)" })),
 	reason: Type.Optional(Type.String({ description: "Reason for being blocked (required for report_blocked)" })),
 	cancelReason: Type.Optional(Type.String({ description: "Why the user wants to cancel (required for cancel_goal)" })),
@@ -160,12 +160,12 @@ export function makeGoalResult(session: GoalSession, text: string) {
 	const budgetInfo: string[] = [];
 	if (state.budget.tokenBudget) {
 		const remaining = Math.max(state.budget.tokenBudget - state.tokensUsed, 0);
-		budgetInfo.push(`Token: ${state.tokensUsed}/${state.budget.tokenBudget} (剩余 ${remaining})`);
+		budgetInfo.push(`Token: ${state.tokensUsed}/${state.budget.tokenBudget} (${remaining} remaining)`);
 	}
 	if (state.budget.timeBudgetMinutes) {
 		const elapsed = getElapsedTimeSeconds(state);
 		const remaining = Math.max(state.budget.timeBudgetMinutes * SECONDS_PER_MINUTE - elapsed, 0);
-		budgetInfo.push(`时间: ${Math.floor(elapsed / SECONDS_PER_MINUTE)}分/${state.budget.timeBudgetMinutes}分 (剩余 ${Math.floor(remaining / SECONDS_PER_MINUTE)}分)`);
+		budgetInfo.push(`Time: ${Math.floor(elapsed / SECONDS_PER_MINUTE)}m/${state.budget.timeBudgetMinutes}m (${Math.floor(remaining / SECONDS_PER_MINUTE)}m remaining)`);
 	}
 	const suffix = budgetInfo.length > 0 ? `\n\n[Budget] ${budgetInfo.join(" | ")}` : "";
 	return {
@@ -177,7 +177,7 @@ export function makeGoalResult(session: GoalSession, text: string) {
 			status: state.status,
 			_render: {
 				type: "task-list" as const,
-				summary: `${getCompletedCount(state.tasks)}/${state.tasks.length} 完成`,
+				summary: `${getCompletedCount(state.tasks)}/${state.tasks.length} completed`,
 				data: {
 					items: state.tasks.map((t) => ({
 						id: t.id,
@@ -192,8 +192,8 @@ export function makeGoalResult(session: GoalSession, text: string) {
 					})),
 					meta: {
 						...(state.budget.tokenBudget ? { "Token": `${state.tokensUsed}/${state.budget.tokenBudget}` } : {}),
-						...(state.budget.timeBudgetMinutes ? { "时间": `${Math.floor(getElapsedTimeSeconds(state) / SECONDS_PER_MINUTE)}分/${state.budget.timeBudgetMinutes}分` } : {}),
-						"轮次": `${state.turnCount}/${state.budget.maxTurns}`,
+						...(state.budget.timeBudgetMinutes ? { "Time": `${Math.floor(getElapsedTimeSeconds(state) / SECONDS_PER_MINUTE)}m/${state.budget.timeBudgetMinutes}m` } : {}),
+						"Turn": `${state.currentTurnIndex}/${state.budget.maxTurns}`,
 					},
 				},
 			},
@@ -222,7 +222,7 @@ export async function executeGoalAction(
 ) {
 	const state = session.state;
 	if (!state) {
-		throw new Error("Goal 模式未激活。使用 /goal <objective> 启动。");
+		throw new Error("Goal mode not active. Use /goal <objective> to start.");
 	}
 
 	switch (params.action) {
@@ -233,8 +233,7 @@ export async function executeGoalAction(
 			const existingIncomplete = getIncompleteTasks(state.tasks);
 			if (state.tasks.length > 0 && existingIncomplete.length > 0) {
 				throw new Error(
-					`已有 ${state.tasks.length} 个任务（${existingIncomplete.length} 个未完成）。` +
-						`如需追加任务请用 add_tasks，如需全部重新规划请用 /goal update。`,
+					`Already has ${state.tasks.length} tasks (${existingIncomplete.length} incomplete). Use add_tasks to append, or /goal update to re-plan.`,
 				);
 			}
 			state.tasks = params.tasks.map((desc: string, i: number) => ({
@@ -245,7 +244,7 @@ export async function executeGoalAction(
 			}));
 			persistGoalState(pi, session, ctx);
 			return makeGoalResult(session,
-				`已创建 ${state.tasks.length} 个任务：\n${state.tasks.map((t) => `  #${t.id}: ${t.description}`).join("\n")}`,
+				`Created ${state.tasks.length} tasks:\n${state.tasks.map((t) => `  #${t.id}: ${t.description}`).join("\n")}`,
 			);
 		}
 
@@ -265,7 +264,7 @@ export async function executeGoalAction(
 			state.tasks.push(...newTasks);
 			persistGoalState(pi, session, ctx);
 			return makeGoalResult(session,
-				`已追加 ${newTasks.length} 个任务：\n${newTasks.map((t) => `  #${t.id}: ${t.description}`).join("\n")}`,
+				`Appended ${newTasks.length} tasks:\n${newTasks.map((t) => `  #${t.id}: ${t.description}`).join("\n")}`,
 			);
 		}
 
@@ -276,7 +275,7 @@ export async function executeGoalAction(
 			const taskIds = params.updates.map((u: { taskId: number; status: string; evidence?: string }) => u.taskId);
 			const duplicateIds = taskIds.filter((id: number, i: number) => taskIds.indexOf(id) !== i);
 			if (duplicateIds.length > 0) {
-				throw new Error(`重复的 taskId: ${[...new Set(duplicateIds)].join(", ")}`);
+				throw new Error(`Duplicate taskIds: ${[...new Set(duplicateIds)].join(", ")}`);
 			}
 			for (const u of params.updates) {
 				const task = state.tasks.find((t) => t.id === u.taskId);
@@ -284,10 +283,10 @@ export async function executeGoalAction(
 					throw new Error(`Task #${u.taskId} not found`);
 				}
 				if (isTerminalTaskStatus(task.status)) {
-					throw new Error(`Task #${task.id} 已处于终态 (${task.status})，不可变更`);
+					throw new Error(`Task #${task.id} already in terminal state (${task.status}), cannot be changed`);
 				}
 				if (u.status === "completed" && (!u.evidence || u.evidence.trim() === "")) {
-					throw new Error(`Task #${task.id}: completed 必须提供 evidence`);
+					throw new Error(`Task #${task.id}: completed requires evidence`);
 				}
 			}
 			const results: string[] = [];
@@ -305,7 +304,7 @@ export async function executeGoalAction(
 				}
 			}
 			persistGoalState(pi, session, ctx);
-			return makeGoalResult(session, `已更新 ${results.length} 个任务：\n${results.join("\n")}`);
+			return makeGoalResult(session, `Updated ${results.length} tasks:\n${results.join("\n")}`);
 		}
 
 		case "list_tasks": {
@@ -314,54 +313,53 @@ export async function executeGoalAction(
 
 		case "complete_goal": {
 			if (!params.evidence || params.evidence.trim() === "") {
-				throw new Error("complete_goal requires evidence — 提供具体的证据证明目标已达成");
+				throw new Error("complete_goal requires evidence — provide concrete proof that the objective has been achieved");
 			}
 			if (state.tasks.length === 0) {
-				throw new Error("请先使用 create_tasks 创建任务清单，再完成目标。");
+				throw new Error("Create a task list with create_tasks before completing the goal.");
 			}
 			const incomplete = getIncompleteTasks(state.tasks);
 			if (incomplete.length > 0) {
 				throw new Error(
-					`还有 ${incomplete.length} 个任务未完成：${incomplete.map((t) => `#${t.id}`).join(", ")}。` +
-						`请先完成这些任务或提供理由说明为什么它们不需要完成。`,
+					`${incomplete.length} tasks still incomplete: ${incomplete.map((t) => `#${t.id}`).join(", ")}. Complete them first or explain why they don't need completion.`,
 				);
 			}
 			const completedCount = getCompletedCount(state.tasks);
 			if (completedCount === 0) {
-				throw new Error("至少需要完成一个任务才能完成目标。全部取消不算达成。");
+				throw new Error("At least one task must be completed. All-cancelled does not count.");
 			}
 			state.status = transitionStatus(state.status, "complete");
 			state.completedAtTurnIndex = state.currentTurnIndex;
 			writeGoalHistoryEntry(pi, session);
 			persistGoalState(pi, session, ctx);
 			const budgetReport: string[] = [];
-			budgetReport.push(`总轮次: ${state.turnCount}`);
-			budgetReport.push(`任务完成: ${getCompletedCount(state.tasks)}/${state.tasks.length}`);
+			budgetReport.push(`Total turns: ${state.currentTurnIndex}`);
+			budgetReport.push(`Tasks completed: ${getCompletedCount(state.tasks)}/${state.tasks.length}`);
 			if (state.budget.tokenBudget) {
-				budgetReport.push(`Token 消耗: ${state.tokensUsed}/${state.budget.tokenBudget}`);
+				budgetReport.push(`Token usage: ${state.tokensUsed}/${state.budget.tokenBudget}`);
 			}
 			const elapsed = getElapsedTimeSeconds(state);
-			budgetReport.push(`用时: ${Math.floor(elapsed / SECONDS_PER_MINUTE)}分${Math.floor(elapsed % SECONDS_PER_MINUTE)}秒`);
+			budgetReport.push(`Duration: ${Math.floor(elapsed / SECONDS_PER_MINUTE)}m${Math.floor(elapsed % SECONDS_PER_MINUTE)}s`);
 			return makeGoalResult(session,
-				`目标已完成!\n证据: ${params.evidence}\n\n--- Budget Report ---\n${budgetReport.join("\n")}`,
+				`Objective completed!\nEvidence: ${params.evidence}\n\n--- Budget Report ---\n${budgetReport.join("\n")}`,
 			);
 		}
 
 		case "report_blocked": {
 			if (!params.reason || params.reason.trim() === "") {
-				throw new Error("report_blocked requires reason — 说明阻塞原因");
+				throw new Error("report_blocked requires reason — describe what is blocking you");
 			}
 			state.lastBlockerReason = params.reason;
 			state.status = transitionStatus(state.status, "blocked");
 			persistGoalState(pi, session, ctx);
-			return makeGoalResult(session, `已报告阻塞。原因: ${params.reason}`);
+			return makeGoalResult(session, `Blocked reported. Reason: ${params.reason}`);
 		}
 
 		case "cancel_goal": {
 			if (isTerminalStatus(state.status)) {
-				throw new Error(`Goal 已处于终态 (${state.status})。`);
+				throw new Error(`Goal is already in terminal state (${state.status}).`);
 			}
-			const reason = params.cancelReason ?? "用户要求取消";
+			const reason = params.cancelReason ?? "User requested cancellation";
 			const goalId = state.goalId;
 			state.status = "cancelled";
 			state.completedAtTurnIndex = state.currentTurnIndex;
@@ -369,7 +367,7 @@ export async function executeGoalAction(
 			persistGoalState(pi, session, ctx);
 			clearGoalSession(session, ctx);
 			return {
-				content: [{ type: "text" as const, text: `Goal 已取消: ${reason}` }],
+				content: [{ type: "text" as const, text: `Goal cancelled: ${reason}` }],
 				details: {
 					action: "cancel",
 					tasks: [],
@@ -377,7 +375,7 @@ export async function executeGoalAction(
 					status: "cancelled",
 					_render: {
 						type: "task-list" as const,
-						summary: "已取消",
+						summary: "Cancelled",
 						data: { items: [], meta: {} },
 					},
 				} satisfies GoalManagerDetails,
@@ -396,13 +394,13 @@ export async function executeGoalAction(
 				throw new Error(`Task #${params.taskId} not found`);
 			}
 			if (isTerminalTaskStatus(parentTask.status)) {
-				throw new Error(`Task #${parentTask.id} 已处于终态 (${parentTask.status})，不能添加 subtask`);
+				throw new Error(`Task #${parentTask.id} already in terminal state (${parentTask.status}), cannot add subtask`);
 			}
 			const subtasks = parentTask.subtasks ?? [];
 			const startId = subtasks.length > 0 ? Math.max(...subtasks.map((s) => s.id)) + 1 : 1;
 			const trimmed = params.texts.map((t: string) => t.trim()).filter((t: string) => t.length > 0);
 			if (trimmed.length === 0) {
-				throw new Error("texts 中至少需要一个非空字符串");
+				throw new Error("texts requires at least one non-empty string");
 			}
 			const newSubtasks: Subtask[] = trimmed.map((text: string, i: number) => ({
 				id: startId + i,
@@ -413,7 +411,7 @@ export async function executeGoalAction(
 			parentTask.subtasks = [...subtasks, ...newSubtasks];
 			persistGoalState(pi, session, ctx);
 			return makeGoalResult(session,
-				`已给 Task #${parentTask.id} 添加 ${newSubtasks.length} 项 subtask：\n` +
+				`Added ${newSubtasks.length} subtasks to Task #${parentTask.id}:\n` +
 				newSubtasks.map((s) => `  - #${parentTask.id}.${s.id}: ${s.text}`).join("\n"),
 			);
 		}
@@ -430,7 +428,7 @@ export async function executeGoalAction(
 				throw new Error(`Task #${params.taskId} not found`);
 			}
 			if (!targetTask.subtasks || targetTask.subtasks.length === 0) {
-				throw new Error(`Task #${params.taskId} 没有 subtask`);
+				throw new Error(`Task #${params.taskId} has no subtasks`);
 			}
 			const results: string[] = [];
 			for (const u of params.subUpdates) {
@@ -439,7 +437,7 @@ export async function executeGoalAction(
 					throw new Error(`Subtask #${params.taskId}.${u.subId} not found`);
 				}
 				if (sub.status === "completed") {
-					throw new Error(`Subtask #${params.taskId}.${sub.id} 已完成，不可变更`);
+					throw new Error(`Subtask #${params.taskId}.${sub.id} already completed, cannot be changed`);
 				}
 				const prev = sub.status;
 				sub.status = u.status;
@@ -448,7 +446,7 @@ export async function executeGoalAction(
 			}
 			persistGoalState(pi, session, ctx);
 			return makeGoalResult(session,
-				`已更新 ${results.length} 项 subtask：\n${results.join("\n")}`,
+				`Updated ${results.length} subtasks:\n${results.join("\n")}`,
 			);
 		}
 
@@ -464,7 +462,7 @@ export async function executeGoalAction(
 				throw new Error(`Task #${params.taskId} not found`);
 			}
 			if (!delTask.subtasks || delTask.subtasks.length === 0) {
-				throw new Error(`Task #${params.taskId} 没有 subtask`);
+				throw new Error(`Task #${params.taskId} has no subtasks`);
 			}
 			const uniqueIds = [...new Set(params.subIds)];
 			const missing = uniqueIds.filter((id) => !delTask.subtasks!.some((s) => s.id === id));
@@ -477,7 +475,7 @@ export async function executeGoalAction(
 			}
 			persistGoalState(pi, session, ctx);
 			return makeGoalResult(session,
-				`已删除 ${uniqueIds.length} 项 subtask，Task #${params.taskId} 剩余 ${delTask.subtasks?.length ?? 0} 项`,
+				`Deleted ${uniqueIds.length} subtasks, Task #${params.taskId} has ${delTask.subtasks?.length ?? 0} remaining`,
 			);
 		}
 

package/src/widget.ts

@@ -39,13 +39,13 @@ export function renderStatusLine(state: GoalRuntimeState, th: ThemeLike): string
 	const completedCount = getCompletedCount(state.tasks);
 	const total = state.tasks.length;
 
-	let text = th.fg("accent", `◆ Goal`) + th.fg("muted", ` ${state.turnCount}/${state.budget.maxTurns}`);
+	let text = th.fg("accent", `◆ Goal`) + th.fg("muted", ` ${state.currentTurnIndex}/${state.budget.maxTurns}`);
 
 	if (total > 0) {
-		text += th.fg("muted", ` | ${completedCount}/${total} 任务`);
+		text += th.fg("muted", ` | ${completedCount}/${total} tasks`);
 		const cancelledCount = state.tasks.filter(t => t.status === "cancelled").length;
 		if (cancelledCount > 0) {
-			text += th.fg("dim", `, ${cancelledCount} 取消`);
+			text += th.fg("dim", `, ${cancelledCount} cancelled`);
 		}
 	}
 
@@ -60,25 +60,25 @@ export function renderStatusLine(state: GoalRuntimeState, th: ThemeLike): string
 	}
 
 	if (state.stallCount > 0) {
-		text += th.fg("warning", ` | ⚠ ${state.stallCount}轮无进展`);
+		text += th.fg("warning", ` | ⚠ ${state.stallCount} turns stalled`);
 	}
 
 	// Status suffix
 	switch (state.status) {
 		case "paused":
-			text += th.fg("warning", " | ⏸ 暂停");
+			text += th.fg("warning", " | ⏸ Paused");
 			break;
 		case "blocked":
-			text += th.fg("error", " | ⊘ 阻塞");
+			text += th.fg("error", " | ⊘ Blocked");
 			break;
 		case "complete":
-			text += th.fg("success", " | ✓ 完成");
+			text += th.fg("success", " | ✓ Completed");
 			break;
 		case "budget_limited":
-			text += th.fg("error", " | ⊗ Token 预算耗尽");
+			text += th.fg("error", " | ⊗ Token budget exhausted");
 			break;
 		case "time_limited":
-			text += th.fg("error", " | ⏱ 时间预算耗尽");
+			text += th.fg("error", " | ⏱ Time budget exhausted");
 			break;
 	}
 
@@ -96,19 +96,19 @@ export function renderTerminalStatusLine(state: GoalRuntimeState, th: ThemeLike)
 	// 状态后缀
 	switch (state.status) {
 		case "complete":
-			text += th.fg("success", " ✓ 完成");
+			text += th.fg("success", " ✓ Completed");
 			break;
 		case "budget_limited":
-			text += th.fg("error", " ⊗ Token 预算耗尽");
+			text += th.fg("error", " ⊗ Token budget exhausted");
 			break;
 		case "time_limited":
-			text += th.fg("error", " ⏱ 时间预算耗尽");
+			text += th.fg("error", " ⏱ Time budget exhausted");
 			break;
 		default:
 			break;
 	}
 
-	text += th.fg("muted", ` | ${completedCount}/${total} 任务`);
+	text += th.fg("muted", ` | ${completedCount}/${total} tasks`);
 
 	// 预算摘要
 	if (state.budget.tokenBudget && state.budget.tokenBudget > 0) {
@@ -137,11 +137,11 @@ export function renderWidgetLines(state: GoalRuntimeState, th: ThemeLike): strin
 	const objDisplay = objSingleLine.length > OBJECTIVE_DISPLAY_LIMIT
 		? objSingleLine.slice(0, OBJECTIVE_TRUNCATE_KEEP) + "..."
 		: objSingleLine;
-	lines.push(th.fg("dim", `目标: ${objDisplay}`));
+	lines.push(th.fg("dim", `Objective: ${objDisplay}`));
 
 	// Task list
 	if (total === 0) {
-		lines.push(th.fg("dim", "  等待创建任务清单..."));
+		lines.push(th.fg("dim", "  Waiting for task list creation..."));
 	} else {
 		for (const t of state.tasks) {
 			const desc = toSingleLine(t.description);
@@ -178,7 +178,7 @@ export function renderWidgetLines(state: GoalRuntimeState, th: ThemeLike): strin
 		const pct = getTimeUsagePercent(state) / PERCENT_FACTOR;
 		const elapsed = getElapsedTimeSeconds(state);
 		const mins = Math.floor(elapsed / SECONDS_PER_MINUTE);
-		lines.push(`  时间: ${renderProgressBar(pct)} ${mins}/${state.budget.timeBudgetMinutes}分钟`);
+		lines.push(`  Time: ${renderProgressBar(pct)} ${mins}/${state.budget.timeBudgetMinutes}min`);
 	}
 
 	return lines;