@unifan/pi-unifan-zh 1.0.35 → 1.0.37

package/extensions/workflow/index.ts

@@ -1,52 +1,103 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import { resolveArtifactPath, type ArtifactType } from "./src/tools/artifact-helper.js";
-import { detectWorkflowState } from "./src/tools/workflow-state.js";
-import { executeSessionCheckpoint } from "./src/tools/session-checkpoint.js";
-import { filterBashOutput } from "./src/filters/bash-output-filter.js";
-import { filterReadOutput } from "./src/filters/read-output-filter.js";
-import { WorkLoopDriver } from "./src/driver/work-loop-driver.js";
-
-const workflowStateParams = Type.Object({
-	repoRoot: Type.String({ description: "Repository root path to scan for workflow artifacts" }),
-});
-
-const artifactHelperParams = Type.Object({
-	repoRoot: Type.String({ description: "Repository root where workflow artifacts are stored" }),
-	artifactType: Type.Union(
-		[
-			Type.Literal("brainstorm"),
-			Type.Literal("plan"),
-			Type.Literal("solution"),
-			Type.Literal("checkpoint"),
-		],
-		{ description: "Target artifact category" },
-	),
-	topic: Type.Optional(Type.String({ description: "Topic or feature name for the artifact" })),
-	date: Type.Optional(Type.String({ description: "Date prefix formatted as YYYY-MM-DD" })),
-	ensureDir: Type.Optional(Type.Boolean({ description: "Whether to create directory if missing" })),
-});
-
-const sessionCheckpointParams = Type.Object({
-	operation: Type.Union(
-		[
-			Type.Literal("save"),
-			Type.Literal("load"),
-			Type.Literal("list"),
-			Type.Literal("fail"),
-			Type.Literal("retry"),
-		],
-		{ description: "Checkpoint action to execute" },
-	),
-	repoRoot: Type.String({ description: "Repository root path" }),
-	planPath: Type.Optional(Type.String({ description: "Path to the plan markdown artifact" })),
-	planSlug: Type.Optional(Type.String({ description: "Slug identifier for the execution plan" })),
-	completedUnits: Type.Optional(
-		Type.Array(Type.String(), { description: "List of completed unit names" }),
-	),
-	failedUnit: Type.Optional(Type.String({ description: "Unit name that encountered a failure" })),
-	error: Type.Optional(Type.String({ description: "Error description or failure details" })),
-});
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ArtifactType } from "./src/tools/artifact-helper.js";
+import type { WorkLoopDriver } from "./src/driver/work-loop-driver.js";
+import { isExplicit03WorkTrigger } from "./src/driver/trigger-matcher.js";
+
+let workDriverInstance: WorkLoopDriver | null = null;
+async function getWorkDriver(): Promise<WorkLoopDriver> {
+	if (!workDriverInstance) {
+		const { WorkLoopDriver: DriverClass } = await import("./src/driver/work-loop-driver.js");
+		workDriverInstance = new DriverClass();
+	}
+	return workDriverInstance;
+}
+
+const workflowStateParams = {
+	type: "object",
+	required: ["repoRoot"],
+	properties: {
+		repoRoot: {
+			type: "string",
+			description: "Repository root path to scan for workflow artifacts",
+		},
+	},
+} as any;
+
+const artifactHelperParams = {
+	type: "object",
+	required: ["repoRoot", "artifactType"],
+	properties: {
+		repoRoot: {
+			type: "string",
+			description: "Repository root where workflow artifacts are stored",
+		},
+		artifactType: {
+			anyOf: [
+				{ type: "string", const: "brainstorm" },
+				{ type: "string", const: "plan" },
+				{ type: "string", const: "solution" },
+				{ type: "string", const: "checkpoint" },
+			],
+			description: "Target artifact category",
+		},
+		topic: {
+			type: "string",
+			description: "Topic or feature name for the artifact",
+		},
+		date: {
+			type: "string",
+			description: "Date prefix formatted as YYYY-MM-DD",
+		},
+		ensureDir: {
+			type: "boolean",
+			description: "Whether to create directory if missing",
+		},
+	},
+} as any;
+
+const sessionCheckpointParams = {
+	type: "object",
+	required: ["operation", "repoRoot"],
+	properties: {
+		operation: {
+			anyOf: [
+				{ type: "string", const: "save" },
+				{ type: "string", const: "load" },
+				{ type: "string", const: "list" },
+				{ type: "string", const: "fail" },
+				{ type: "string", const: "retry" },
+			],
+			description: "Checkpoint action to execute",
+		},
+		repoRoot: {
+			type: "string",
+			description: "Repository root path",
+		},
+		planPath: {
+			type: "string",
+			description: "Path to the plan markdown artifact",
+		},
+		planSlug: {
+			type: "string",
+			description: "Slug identifier for the execution plan",
+		},
+		completedUnits: {
+			type: "array",
+			items: {
+				type: "string",
+			},
+			description: "List of completed unit names",
+		},
+		failedUnit: {
+			type: "string",
+			description: "Unit name that encountered a failure",
+		},
+		error: {
+			type: "string",
+			description: "Error description or failure details",
+		},
+	},
+} as any;
 
 export default function workflowExtension(pi: ExtensionAPI) {
 	// 1. Register workflow_state tool (Core engine for 00-next)
@@ -56,7 +107,8 @@ export default function workflowExtension(pi: ExtensionAPI) {
 		description:
 			"Scan repository artifacts (brainstorms, plans, checkpoints, solutions) and determine current stage and recommended next skill.",
 		parameters: workflowStateParams,
-		async execute(_toolCallId, params) {
+		async execute(_toolCallId, params: any) {
+			const { detectWorkflowState } = await import("./src/tools/workflow-state.js");
 			const result = await detectWorkflowState(params.repoRoot);
 			return {
 				content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
@@ -72,7 +124,8 @@ export default function workflowExtension(pi: ExtensionAPI) {
 		description:
 			"Resolve and optionally create standard Compound Engineering artifact paths under docs/ or .context/.",
 		parameters: artifactHelperParams,
-		async execute(_toolCallId, params) {
+		async execute(_toolCallId, params: any) {
+			const { resolveArtifactPath } = await import("./src/tools/artifact-helper.js");
 			const result = await resolveArtifactPath({
 				repoRoot: params.repoRoot,
 				artifactType: params.artifactType as ArtifactType,
@@ -94,7 +147,8 @@ export default function workflowExtension(pi: ExtensionAPI) {
 		description:
 			"Manage plan execution checkpoints: save completed units, load breakpoints, record errors, and retry failed units.",
 		parameters: sessionCheckpointParams,
-		async execute(_toolCallId, params) {
+		async execute(_toolCallId, params: any) {
+			const { executeSessionCheckpoint } = await import("./src/tools/session-checkpoint.js");
 			const result = await executeSessionCheckpoint({
 				operation: params.operation,
 				repoRoot: params.repoRoot,
@@ -125,6 +179,7 @@ export default function workflowExtension(pi: ExtensionAPI) {
 		if (textBlocks.length === 0) return undefined;
 
 		const output = textBlocks.map((b) => b.text ?? "").join("");
+		const { filterBashOutput } = await import("./src/filters/bash-output-filter.js");
 		const result = filterBashOutput({
 			command,
 			output,
@@ -163,6 +218,7 @@ export default function workflowExtension(pi: ExtensionAPI) {
 		const isImage =
 			(event.content as Array<{ type: string }>)?.some((b) => b.type === "image") ?? false;
 
+		const { filterReadOutput } = await import("./src/filters/read-output-filter.js");
 		const result = filterReadOutput({
 			path: filePath,
 			output,
@@ -185,58 +241,143 @@ export default function workflowExtension(pi: ExtensionAPI) {
 		};
 	});
 
-	// 6. User Command: /workflow (查看工作流总览与 03-work 自主循环状态)
+	// 6. User Command: /workflow (查看工作流全阶段看板与自主循环控制)
 	pi.registerCommand("workflow", {
-		description: "查看当前项目的复合工程流状态与下一步推荐技能",
-		async handler(_args, ctx) {
+		description: "查看复合工程工作流全流程步骤状态看板与自主干活循环控制",
+		async handler(args, ctx) {
+			const sub = (args || "").trim().toLowerCase();
+			const workDriver = await getWorkDriver();
+
+			if (sub === "pause" || sub === "暂停") {
+				if (workDriver.getStatus().isActive) {
+					detachEscapeListener();
+					await workDriver.pause("用户执行 /workflow pause");
+					ctx.ui?.setStatus?.("workflow", undefined);
+					ctx.ui?.notify?.("⏸️ 03-work 自主循环已安全暂停。", "info");
+				} else {
+					ctx.ui?.notify?.("⚪ 03-work 当前未处于活跃运行状态。", "info");
+				}
+				return;
+			}
+
+			if (sub === "resume" || sub === "继续") {
+				workDriver.setRepoRoot(ctx.cwd || process.cwd());
+				const res = await workDriver.start();
+				if (res.success && res.status.isActive) {
+					attachEscapeListener(ctx);
+					ctx.ui?.setStatus?.(
+						"workflow",
+						`🔄 03-work 自主干活 [${res.status.completedUnits.length}/${res.status.allUnits.length}]`,
+					);
+					ctx.ui?.notify?.("🚀 03-work 自主循环已恢复驱动。", "info");
+				} else {
+					ctx.ui?.notify?.(res.message, "info");
+				}
+				return;
+			}
+
+			if (sub === "hide" || sub === "off" || sub === "close" || sub === "关闭" || sub === "隐藏") {
+				ctx.ui?.setWidget?.("workflow", undefined);
+				ctx.ui?.setStatus?.("workflow", undefined);
+				ctx.ui?.notify?.("工作流状态栏已隐藏。", "info");
+				return;
+			}
+
+			const { detectWorkflowState } = await import("./src/tools/workflow-state.js");
+			const { buildWorkflowDashboard, buildWorkflowWidgetLines } = await import(
+				"./src/tools/workflow-dashboard.js"
+			);
 			const repoRoot = ctx.cwd || process.cwd();
 			const state = await detectWorkflowState(repoRoot);
 			const workStatus = workDriver.getStatus();
 
-			const msg = [
-				`🎯 **复合工程工作流状态 (Compound Engineering)**`,
-				`📁 仓库路径: \`${state.repoRoot}\``,
-				`📊 当前阶段: **${state.stage.toUpperCase()}**`,
-				`🚀 推荐下一步: \`/skill:${state.recommendedSkill}\``,
-				`💡 理由: ${state.recommendationReason}`,
-				``,
-				workStatus.isActive
-					? `⚡ **03-work 自主循环运行中**: [${workStatus.completedUnits.length}/${workStatus.allUnits.length}] 当前推进: **${workStatus.currentUnit || "全部完成"}**`
-					: `⚡ **03-work 自主循环状态**: ⚪ 空闲（调用 /skill:03-work 即可自动循环驱动）`,
-				``,
-				`📋 **产物概览**:`,
-				`- 需求文档 (Brainstorms): ${state.brainstorms.length} 个 ${state.latestBrainstorm ? `(最新: ${state.latestBrainstorm.filename})` : ""}`,
-				`- 执行计划 (Plans): ${state.plans.length} 个 ${state.latestPlan ? `(最新: ${state.latestPlan.filename})` : ""}`,
-				`- 运行断点 (Checkpoints): ${state.checkpoints.length} 个 ${state.activeCheckpoint ? `(已完成: ${state.activeCheckpoint.completedUnits.length} 单元)` : ""}`,
-				`- 避坑经验 (Solutions): ${state.solutions.length} 个 ${state.latestSolution ? `(最新: ${state.latestSolution.filename})` : ""}`,
-			].join("\n");
-
+			const dashboard = buildWorkflowDashboard(state, workStatus);
 			if (ctx.hasUI) {
-				ctx.ui.notify?.(msg, "info");
+				ctx.ui.notify?.(dashboard, "info");
+				const widgetLines = buildWorkflowWidgetLines(state, workStatus);
+				ctx.ui.setWidget?.("workflow", widgetLines, { placement: "aboveEditor" });
 			}
 		},
 	});
 
-	// 7. 03-work 原生自主循环驱动引擎 (无须额外命令，直接在 03-work 中原生生效)
-	const workDriver = new WorkLoopDriver();
+	pi.registerCommand("workflow-pause", {
+		description: "暂停当前正在运行的 03-work 自主干活循环 (同 Esc / 输入 '暂停')",
+		async handler(_args, ctx) {
+			const workDriver = await getWorkDriver();
+			if (workDriver.getStatus().isActive) {
+				detachEscapeListener();
+				await workDriver.pause("用户执行 /workflow-pause");
+				ctx.ui?.setStatus?.("workflow", undefined);
+				ctx.ui?.notify?.("⏸️ 03-work 自主循环已安全暂停。", "info");
+			} else {
+				ctx.ui?.notify?.("⚪ 03-work 当前未处于活跃运行状态。", "info");
+			}
+		},
+	});
 
-	// 监听用户输入与技能启动：当调用 03-work 或请求恢复执行时，自动启动自主循环驱动
+	pi.registerCommand("workflow-resume", {
+		description: "恢复当前计划的 03-work 自主干活循环 (同 /skill:03-work / 输入 '继续干活')",
+		async handler(_args, ctx) {
+			const workDriver = await getWorkDriver();
+			workDriver.setRepoRoot(ctx.cwd || process.cwd());
+			const res = await workDriver.start();
+			if (res.success && res.status.isActive) {
+				attachEscapeListener(ctx);
+				ctx.ui?.setStatus?.(
+					"workflow",
+					`🔄 03-work 自主干活 [${res.status.completedUnits.length}/${res.status.allUnits.length}]`,
+				);
+				ctx.ui?.notify?.("🚀 03-work 自主循环已恢复驱动。", "info");
+			} else {
+				ctx.ui?.notify?.(res.message, "info");
+			}
+		},
+	});
+
+	// 7. 03-work 原生自主循环驱动引擎与极轻量按需键盘中断监听
+	// 仅在 03-work 自主循环运行时按需挂载 Esc 监听，暂停或结束时立即脱钩，日常打字 0 开销
+	let terminalInputUnsub: (() => void) | null = null;
+	async function attachEscapeListener(ctx: ExtensionContext) {
+		if (ctx.hasUI && !terminalInputUnsub && ctx.ui?.onTerminalInput) {
+			const { matchesKey } = await import("@earendil-works/pi-tui");
+			terminalInputUnsub = ctx.ui.onTerminalInput((data: string) => {
+				if (
+					(data === "\x1b" || matchesKey(data, "escape")) &&
+					workDriverInstance &&
+					workDriverInstance.getStatus().isActive
+				) {
+					detachEscapeListener();
+					workDriverInstance.pause("用户按 Esc 中断");
+					ctx.ui?.setStatus?.("workflow", undefined);
+					ctx.ui?.notify?.(
+						"⏸️ 03-work 自主循环已响应 Esc 安全暂停。随时输入“继续”或调用 /skill:03-work 即可恢复。",
+						"info",
+					);
+					// 不消费按键，透传给宿主让 Pi 终止当前正在运行的模型回合或工具命令
+					return undefined;
+				}
+				return undefined;
+			});
+		}
+	}
+
+	function detachEscapeListener() {
+		if (terminalInputUnsub) {
+			terminalInputUnsub();
+			terminalInputUnsub = null;
+		}
+	}
+
+	// 监听用户输入与技能启动：只有显式触发 03-work 时才启动自主循环（绝不读取 systemPrompt）
 	pi.on("before_agent_start", async (event, ctx) => {
-		const promptLower = event.prompt.toLowerCase();
-		const is03Work =
-			event.prompt.includes("03-work") ||
-			event.systemPrompt.includes("03-work") ||
-			(promptLower.includes("03") &&
-				(promptLower.includes("work") ||
-					promptLower.includes("继续") ||
-					promptLower.includes("恢复") ||
-					promptLower.includes("resume") ||
-					promptLower.includes("干活")));
-
-		if (is03Work && !workDriver.getStatus().isActive) {
+		const is03Work = isExplicit03WorkTrigger(event.prompt);
+
+		if (is03Work && (!workDriverInstance || !workDriverInstance.getStatus().isActive)) {
+			const workDriver = await getWorkDriver();
 			workDriver.setRepoRoot(ctx.cwd || process.cwd());
 			const res = await workDriver.start();
 			if (res.success && res.status.isActive) {
+				attachEscapeListener(ctx);
 				const nextUnit = res.status.currentUnit ? `下一个: ${res.status.currentUnit}` : "准备就绪";
 				ctx.ui?.setStatus?.(
 					"workflow",
@@ -246,14 +387,36 @@ export default function workflowExtension(pi: ExtensionAPI) {
 		}
 	});
 
-	// 监听用户打断指令：用户若输入“暂停”或“停止”，自动安全挂起 03 自主循环
+	const WORKFLOW_SHORTCUTS: Record<string, string> = {
+		"00": "00-next",
+		"/00": "00-next",
+		"01": "01-brainstorm",
+		"/01": "01-brainstorm",
+		"02": "02-plan",
+		"/02": "02-plan",
+		"03": "03-work",
+		"/03": "03-work",
+		"04": "04-review",
+		"/04": "04-review",
+		"05": "05-learn",
+		"/05": "05-learn",
+	};
+
+	// 监听用户打断指令与极简快捷指令（如输入 01 自动转为 /skill:01-brainstorm）
 	pi.on("input", async (event, ctx) => {
-		const text = event.text.trim().toLowerCase();
+		if (event.source === "extension") return { action: "continue" };
+
+		const raw = event.text.trim();
+		const lower = raw.toLowerCase();
+
+		// 1. 暂停/打断指令：用户若输入“暂停”或“停止”，自动安全挂起 03 自主循环
 		if (
-			workDriver.getStatus().isActive &&
-			(text === "暂停" || text === "停止" || text === "pause" || text === "stop")
+			workDriverInstance &&
+			workDriverInstance.getStatus().isActive &&
+			(lower === "暂停" || lower === "停止" || lower === "pause" || lower === "stop")
 		) {
-			await workDriver.pause("用户手动输入暂停");
+			detachEscapeListener();
+			await workDriverInstance.pause("用户手动输入暂停");
 			ctx.ui?.setStatus?.("workflow", undefined);
 			ctx.ui?.notify?.(
 				"⏸️ 03-work 自主循环已暂停。随时输入“继续”或调用 /skill:03-work 即可恢复。",
@@ -261,15 +424,68 @@ export default function workflowExtension(pi: ExtensionAPI) {
 			);
 			return { action: "handled" };
 		}
+
+		// 2. 阶段编号快捷直达：输入 00~05 自动转换为 /skill:0x-xxx
+		const match = raw.match(/^(\/?0[0-5])(?:\s+(.*))?$/);
+		if (match) {
+			const shortcutKey = match[1];
+			const skillName = WORKFLOW_SHORTCUTS[shortcutKey];
+			if (skillName) {
+				// 若当前正在 03 自主干活中，切换阶段时先优雅暂停 03
+				if (skillName !== "03-work" && workDriverInstance && workDriverInstance.getStatus().isActive) {
+					detachEscapeListener();
+					await workDriverInstance.pause(`用户通过快捷键切换至 ${skillName}`);
+					ctx.ui?.setStatus?.("workflow", undefined);
+				}
+				const rest = match[2] ? ` ${match[2]}` : "";
+				return { action: "transform", text: `/skill:${skillName}${rest}` };
+			}
+		}
+
 		return { action: "continue" };
 	});
 
+	// 监听单轮结束 (turn_end)：若因 Ctrl+C / Esc 导致当前轮次被中止，立即安全挂起
+	pi.on("turn_end", async (event, ctx) => {
+		const msg = event.message as any;
+		if (
+			workDriverInstance &&
+			workDriverInstance.getStatus().isActive &&
+			msg?.role === "assistant" &&
+			msg?.stopReason === "aborted"
+		) {
+			detachEscapeListener();
+			await workDriverInstance.pause("检测到助理回合中断 (stopReason: aborted)");
+			ctx.ui?.setStatus?.("workflow", undefined);
+		}
+	});
+
+	// 监听整段运行结束 (agent_end)：检测 abort 信号或中止消息并挂起，防止 runaway 循环
+	pi.on("agent_end", async (event, ctx) => {
+		if (workDriverInstance && workDriverInstance.getStatus().isActive) {
+			const hasAborted =
+				ctx.signal?.aborted ||
+				event.messages.some((m: any) => m?.role === "assistant" && m?.stopReason === "aborted");
+			if (hasAborted) {
+				detachEscapeListener();
+				await workDriverInstance.pause("检测到会话中断信号 (Ctrl+C / Esc)");
+				ctx.ui?.setStatus?.("workflow", undefined);
+			}
+		}
+	});
+
 	// 核心事件循环：每个回合结束后，若仍有未完成单元，自动注入下一回合实现“不做完不停机”
 	pi.on("agent_settled", async (_event, ctx) => {
-		await workDriver.onAgentSettled(ctx, pi);
+		if (workDriverInstance && workDriverInstance.getStatus().isActive) {
+			await workDriverInstance.onAgentSettled(ctx, pi);
+			if (!workDriverInstance.getStatus().isActive) {
+				detachEscapeListener();
+			}
+		}
 	});
 
 	pi.on("session_shutdown", async () => {
-		workDriver.cancelTimer();
+		detachEscapeListener();
+		workDriverInstance?.cancelTimer();
 	});
 }

package/extensions/workflow/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unifan/pi-workflow-zh",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Pi 复合工程工作流引擎（状态感知 / 断点续跑 / 输出压缩 / 自动化工具集）",
   "type": "module",
   "main": "index.ts",

package/extensions/workflow/skills/00-next/SKILL.md

@@ -34,8 +34,5 @@ description: "检查工作流产物并推荐/导航到最佳的下一步技能
 ## 执行流程
 
 1. 调用 `workflow_state({ repoRoot: "." })`。
-2. 输出简洁明了的状态面板：
-   - 🎯 当前阶段
-   - 🚀 推荐技能（如 `/skill:01-brainstorm`、`/skill:02-plan` 等）
-   - 💡 推荐理由
-3. 询问用户是否立刻进入推荐技能。
+2. 输出状态概览与推荐技能（亦可随时运行 `/workflow` 查看全量看板）。
+3. 询问用户是否进入推荐技能。

package/extensions/workflow/src/driver/trigger-matcher.ts

@@ -0,0 +1,39 @@
+/**
+ * Pure, lightweight trigger matcher for 03-work.
+ * Has ZERO external imports to ensure near-zero cold startup overhead.
+ */
+export function isExplicit03WorkTrigger(prompt: string): boolean {
+	if (!prompt) return false;
+	const trimmed = prompt.trim();
+	const lower = trimmed.toLowerCase();
+
+	// 1. Direct skill invocation or slash command
+	if (
+		lower.startsWith("/skill:03-work") ||
+		lower === "/skill:03" ||
+		lower.startsWith("03-work")
+	) {
+		return true;
+	}
+
+	// 2. Strict keywords and natural language commands to start/resume 03 work
+	const strictPatterns = [
+		/^(\/)?(03|03-work)$/i,
+		/^开始(03|干活|编码|实现|写代码)/,
+		/^执行(03|03-work|干活)/,
+		/^自主(干活|工作|编码)/,
+		/^(继续|恢复)(干活|03|工作|work)/i,
+		/^resume\s+(03|work)/i,
+	];
+
+	if (strictPatterns.some((p) => p.test(trimmed))) {
+		return true;
+	}
+
+	// 3. Autonomous continuation follow-up prompt generated by the driver itself
+	if (trimmed.startsWith("【03-work 自主循环驱动引擎")) {
+		return true;
+	}
+
+	return false;
+}

package/extensions/workflow/src/driver/work-loop-driver.ts

@@ -95,6 +95,8 @@ export async function findLatestPlanFile(repoRoot: string): Promise<string | nul
 	}
 }
 
+export { isExplicit03WorkTrigger } from "./trigger-matcher.js";
+
 /**
  * Autonomous Loop Driver for 03-work.
  * Ensures the agent drives continuously across turns until all planned units are 100% finished.
@@ -282,13 +284,29 @@ export class WorkLoopDriver {
 	async onAgentSettled(ctx: ExtensionContext, pi: ExtensionAPI): Promise<void> {
 		if (!this.isActive || !this.planPath) return;
 
-		// 1. Check if user aborted (Esc pressed or abort signal)
+		// 1. Check if user aborted (Esc pressed, abort signal, or aborted assistant message)
 		if (ctx.signal?.aborted) {
 			await this.pause("检测到用户中断信号 (Esc/Abort)");
+			ctx.ui?.setStatus?.("workflow", undefined);
 			ctx.ui?.notify?.("⏸️ 03-work 自主循环已响应中断信号安全暂停。", "info");
 			return;
 		}
 
+		try {
+			const branch = ctx.sessionManager?.getBranch?.() ?? [];
+			const lastMsgEntry = branch
+				.slice()
+				.reverse()
+				.find((e: any) => e?.type === "message" && e?.message?.role === "assistant");
+			const lastAssistantMsg = (lastMsgEntry as any)?.message;
+			if (lastAssistantMsg?.stopReason === "aborted") {
+				await this.pause("检测到会话中断 (stopReason: aborted)");
+				ctx.ui?.setStatus?.("workflow", undefined);
+				ctx.ui?.notify?.("⏸️ 03-work 自主循环已响应中断信号安全暂停。", "info");
+				return;
+			}
+		} catch {}
+
 		// 2. Re-read checkpoint from disk to see what the agent achieved in this turn
 		const cpResult = await executeSessionCheckpoint({
 			operation: "load",

package/extensions/workflow/src/tools/workflow-dashboard.ts

@@ -0,0 +1,325 @@
+import type { WorkflowStateResult } from "./workflow-state.js";
+import type { WorkStatus } from "../driver/work-loop-driver.js";
+
+export interface WorkflowStepItem {
+	number: string;
+	id: "01-brainstorm" | "02-plan" | "03-work" | "04-review" | "05-learn";
+	title: string;
+	status: "completed" | "in_progress" | "ready" | "pending" | "idle";
+	statusLabel: string;
+	detail: string;
+	isCurrent: boolean;
+}
+
+/**
+ * Generates an ASCII progress bar, e.g. [██████░░░░░░░░░░] 38%
+ */
+export function renderProgressBar(completed: number, total: number, barLength = 12): string {
+	if (total <= 0) return "░".repeat(barLength);
+	const ratio = Math.min(1, Math.max(0, completed / total));
+	const filled = Math.round(ratio * barLength);
+	const empty = barLength - filled;
+	return "█".repeat(filled) + "░".repeat(empty);
+}
+
+/**
+ * Derives the full 5-step status array from workflow state and driver status.
+ */
+export function deriveWorkflowSteps(
+	state: WorkflowStateResult,
+	workStatus: WorkStatus,
+): WorkflowStepItem[] {
+	// Determine current active step
+	let currentStepId: WorkflowStepItem["id"] = state.recommendedSkill || "01-brainstorm";
+	if (workStatus.isActive) {
+		currentStepId = "03-work";
+	}
+
+	const steps: WorkflowStepItem[] = [];
+
+	// Step 01: 01-brainstorm
+	const hasBrainstorm = state.brainstorms.length > 0;
+	steps.push({
+		number: "01",
+		id: "01-brainstorm",
+		title: "需求发现与规格说明",
+		status: hasBrainstorm ? "completed" : "ready",
+		statusLabel: hasBrainstorm ? "[已完成]" : "[就绪]",
+		detail: hasBrainstorm
+			? `${state.brainstorms.length} 个需求文档 (最新: ${state.latestBrainstorm?.filename || "-"})`
+			: "建议梳理目标、边界与成功标准",
+		isCurrent: currentStepId === "01-brainstorm",
+	});
+
+	// Step 02: 02-plan
+	const hasPlan = state.plans.length > 0;
+	steps.push({
+		number: "02",
+		id: "02-plan",
+		title: "架构设计与TDD计划",
+		status: hasPlan ? "completed" : hasBrainstorm ? "ready" : "pending",
+		statusLabel: hasPlan ? "[已完成]" : hasBrainstorm ? "[就绪]" : "[待办]",
+		detail: hasPlan
+			? `${state.plans.length} 个计划文档 (最新: ${state.latestPlan?.filename || "-"})`
+			: hasBrainstorm
+				? "可基于需求拆解架构与 TDD 实施单元"
+				: "待梳理需求文档",
+		isCurrent: currentStepId === "02-plan",
+	});
+
+	// Step 03: 03-work
+	const totalUnits = state.totalUnitsCount ?? workStatus.allUnits.length;
+	const completedUnits = state.completedUnitsCount ?? workStatus.completedUnits.length;
+	const remainingUnits = state.remainingUnitsCount ?? workStatus.remainingUnits.length;
+
+	let workStepStatus: WorkflowStepItem["status"] = "idle";
+	let workStepLabel = "[空闲]";
+	let workStepDetail = "待制定带实施单元的计划文档";
+
+	if (workStatus.isActive) {
+		workStepStatus = "in_progress";
+		workStepLabel = "[⚡ 运行中]";
+		const percent = totalUnits > 0 ? Math.round((completedUnits / totalUnits) * 100) : 0;
+		workStepDetail = `单元进度: [${renderProgressBar(completedUnits, totalUnits, 8)}] ${completedUnits}/${totalUnits} (${percent}%) 当前: ${workStatus.currentUnit || "就绪"}`;
+	} else if (workStatus.lastMessage && workStatus.lastMessage.includes("暂停")) {
+		workStepStatus = "in_progress";
+		workStepLabel = "[⏸️ 已暂停]";
+		const percent = totalUnits > 0 ? Math.round((completedUnits / totalUnits) * 100) : 0;
+		workStepDetail = `单元进度: [${renderProgressBar(completedUnits, totalUnits, 8)}] ${completedUnits}/${totalUnits} (${percent}%)，已安全暂存`;
+	} else if (state.activeCheckpoint?.failedUnit) {
+		workStepStatus = "in_progress";
+		workStepLabel = "[🛑 遇错暂停]";
+		workStepDetail = `失败单元: ${state.activeCheckpoint.failedUnit}，建议排查报错`;
+	} else if (totalUnits > 0) {
+		if (remainingUnits === 0) {
+			workStepStatus = "completed";
+			workStepLabel = "[已完成]";
+			workStepDetail = `全部 ${totalUnits} 个规划单元测试均已绿灯通过`;
+		} else if (completedUnits > 0) {
+			workStepStatus = "in_progress";
+			workStepLabel = "[进行中]";
+			const percent = Math.round((completedUnits / totalUnits) * 100);
+			workStepDetail = `单元进度: [${renderProgressBar(completedUnits, totalUnits, 8)}] ${completedUnits}/${totalUnits} (${percent}%) 下一待办: ${state.nextUnitId || "-"}`;
+		} else {
+			workStepStatus = "ready";
+			workStepLabel = "[就绪]";
+			workStepDetail = `计划已就绪，共 ${totalUnits} 个单元待编码`;
+		}
+	} else if (hasPlan) {
+		workStepStatus = "ready";
+		workStepLabel = "[就绪]";
+		workStepDetail = "计划文档已存在，随时可启动自主干活";
+	}
+
+	steps.push({
+		number: "03",
+		id: "03-work",
+		title: "自主编码与循环推进",
+		status: workStepStatus,
+		statusLabel: workStepLabel,
+		detail: workStepDetail,
+		isCurrent: currentStepId === "03-work",
+	});
+
+	// Step 04: 04-review
+	const isWorkDone = totalUnits > 0 && remainingUnits === 0;
+	steps.push({
+		number: "04",
+		id: "04-review",
+		title: "代码质量与规格审查",
+		status: isWorkDone ? "ready" : state.stage === "completed" ? "completed" : "pending",
+		statusLabel: state.stage === "completed" ? "[已完成]" : isWorkDone ? "[就绪]" : "[待办]",
+		detail: isWorkDone
+			? "单元实现已完毕，可启动全量代码审查与回归验证"
+			: state.stage === "completed"
+				? "审查已完成，项目规格与质量达标"
+				: "建议在 Implementation Units 验证后审查",
+		isCurrent: currentStepId === "04-review",
+	});
+
+	// Step 05: 05-learn
+	const hasSolutions = state.solutions.length > 0;
+	steps.push({
+		number: "05",
+		id: "05-learn",
+		title: "知识复盘与经验沉淀",
+		status: hasSolutions ? "completed" : state.stage === "completed" ? "ready" : "pending",
+		statusLabel: hasSolutions ? "[已沉淀]" : state.stage === "completed" ? "[就绪]" : "[待办]",
+		detail: hasSolutions
+			? `${state.solutions.length} 个避坑指南 (最新: ${state.latestSolution?.filename || "-"})`
+			: state.stage === "completed"
+				? "闭环已完成，可沉淀高价值非平凡解决方案"
+				: "在开发与审查完毕后进行",
+		isCurrent: currentStepId === "05-learn",
+	});
+
+	return steps;
+}
+
+/**
+ * Helper to calculate terminal display width considering CJK full-width characters and ANSI codes.
+ */
+export function getVisibleWidth(str: string): number {
+	let width = 0;
+	for (let i = 0; i < str.length; i++) {
+		const code = str.charCodeAt(i);
+		if (code === 0x1b && str[i + 1] === "[") {
+			const mIdx = str.indexOf("m", i);
+			if (mIdx !== -1) {
+				i = mIdx;
+				continue;
+			}
+		}
+		if (
+			(code >= 0x1100 && code <= 0x115f) ||
+			(code >= 0x2e80 && code <= 0xa4cf) ||
+			(code >= 0xac00 && code <= 0xd7a3) ||
+			(code >= 0xf900 && code <= 0xfaff) ||
+			(code >= 0xfe10 && code <= 0xfe19) ||
+			(code >= 0xfe30 && code <= 0xfe6f) ||
+			(code >= 0xff00 && code <= 0xff60) ||
+			(code >= 0xffe0 && code <= 0xffe6) ||
+			code >= 0x10000
+		) {
+			width += 2;
+		} else {
+			width += 1;
+		}
+	}
+	return width;
+}
+
+/**
+ * Truncates string to a maximum visible width, appending an ellipsis if truncated.
+ */
+export function truncateToVisibleWidth(str: string, maxWidth: number): string {
+	if (getVisibleWidth(str) <= maxWidth) return str;
+	let currentWidth = 0;
+	let result = "";
+	for (let i = 0; i < str.length; i++) {
+		const char = str[i];
+		const code = str.charCodeAt(i);
+		const charWidth =
+			(code >= 0x1100 && code <= 0x115f) ||
+			(code >= 0x2e80 && code <= 0xa4cf) ||
+			(code >= 0xac00 && code <= 0xd7a3) ||
+			(code >= 0xf900 && code <= 0xfaff) ||
+			(code >= 0xfe10 && code <= 0xfe19) ||
+			(code >= 0xfe30 && code <= 0xfe6f) ||
+			(code >= 0xff00 && code <= 0xff60) ||
+			(code >= 0xffe0 && code <= 0xffe6) ||
+			code >= 0x10000
+				? 2
+				: 1;
+
+		if (currentWidth + charWidth + 1 > maxWidth) {
+			result += "…";
+			break;
+		}
+		result += char;
+		currentWidth += charWidth;
+	}
+	return result;
+}
+
+export function renderBoxHeader(left: string, right = "", width = 76): string {
+	const inner = width - 2;
+	const l = `─ ${left} `;
+	const r = right ? ` ${right} ─` : "─";
+	const fixed = getVisibleWidth(l) + getVisibleWidth(r);
+	const fill = Math.max(1, inner - fixed);
+	return `╭${l}${"─".repeat(fill)}${r}╮`;
+}
+
+export function renderBoxLine(content: string, width = 76): string {
+	const inner = width - 4;
+	const truncated = truncateToVisibleWidth(content, inner);
+	const visibleLen = getVisibleWidth(truncated);
+	const pad = Math.max(0, inner - visibleLen);
+	return `│ ${truncated}${" ".repeat(pad)} │`;
+}
+
+export function renderBoxFooter(text = "", width = 76): string {
+	const inner = width - 2;
+	if (!text) return `╰${"─".repeat(inner)}╯`;
+	const t = `─ ${text} `;
+	const fill = Math.max(1, inner - getVisibleWidth(t));
+	return `╰${t}${"─".repeat(fill)}╯`;
+}
+
+/**
+ * Builds a structured, visually polished compact ASCII status dashboard (Goal-style, 7 lines).
+ */
+export function buildWorkflowDashboard(
+	state: WorkflowStateResult,
+	workStatus: WorkStatus,
+	boxWidth = 76,
+): string {
+	const steps = deriveWorkflowSteps(state, workStatus);
+	const currentStep = steps.find((s) => s.isCurrent) || steps[0];
+
+	const totalUnits = state.totalUnitsCount ?? workStatus.allUnits.length;
+	const completedUnits = state.completedUnitsCount ?? workStatus.completedUnits.length;
+	const percent = totalUnits > 0 ? Math.round((completedUnits / totalUnits) * 100) : 0;
+
+	const lines: string[] = [];
+
+	// 1. Header: 1 line
+	const progressSummary =
+		totalUnits > 0
+			? `[${renderProgressBar(completedUnits, totalUnits, 8)}] ${completedUnits}/${totalUnits} (${percent}%)`
+			: "";
+	const leftTitle = `Workflow Dashboard ─ [${currentStep.id} ${currentStep.statusLabel}]`;
+	lines.push(renderBoxHeader(leftTitle, progressSummary, boxWidth));
+
+	// 2. Exactly 5 steps: 5 lines (1 clean line per step)
+	for (const step of steps) {
+		const marker = step.isCurrent ? "▶" : step.status === "completed" ? "✓" : "·";
+		const rowContent = `  ${marker} [${step.number}] ${step.id.padEnd(14)} ${step.statusLabel.padEnd(8)} · ${step.detail}`;
+		lines.push(renderBoxLine(rowContent, boxWidth));
+	}
+
+	// 3. Footer: 1 line
+	lines.push(renderBoxFooter("Esc/Ctrl+C: 暂停 · 继续: 恢复 · /workflow", boxWidth));
+
+	return lines.join("\n");
+}
+
+/**
+ * Builds ultra-compact 1-line display for status bar or above-editor widget.
+ */
+export function buildWorkflowWidgetLines(
+	state: WorkflowStateResult,
+	workStatus: WorkStatus,
+): string[] {
+	const steps = deriveWorkflowSteps(state, workStatus);
+	const currentStep = steps.find((s) => s.isCurrent) || steps[0];
+
+	const pipeline = steps
+		.map((s) => {
+			const sym = s.isCurrent ? "▶" : s.status === "completed" ? "✓" : "·";
+			return `${s.number}${sym}`;
+		})
+		.join(" ");
+
+	const totalUnits = state.totalUnitsCount ?? workStatus.allUnits.length;
+	const completedUnits = state.completedUnitsCount ?? workStatus.completedUnits.length;
+	const pct = totalUnits > 0 ? Math.round((completedUnits / totalUnits) * 100) : 0;
+
+	if (workStatus.isActive) {
+		const cur = workStatus.currentUnit ? ` 当前: ${workStatus.currentUnit}` : "";
+		return [
+			`⚡ [${pipeline}] 03-work [${renderProgressBar(completedUnits, totalUnits, 6)}] ${completedUnits}/${totalUnits} (${pct}%)${cur} | [Esc 暂停]`,
+		];
+	}
+
+	if (workStatus.lastMessage && workStatus.lastMessage.includes("暂停")) {
+		return [
+			`⏸️ [${pipeline}] 03-work 已暂停 [${completedUnits}/${totalUnits} 单元] | 输入“继续”恢复 | /workflow 查看看板`,
+		];
+	}
+
+	return [
+		`🎯 [${pipeline}] 当前: [${currentStep.number}] ${currentStep.id} ${currentStep.statusLabel} | /workflow 查看看板`,
+	];
+}

package/extensions/workflow/tests/workflow.test.mjs

@@ -22,8 +22,10 @@ const tsFiles = [
 	"src/tools/artifact-helper",
 	"src/tools/session-checkpoint",
 	"src/tools/workflow-state",
+	"src/tools/workflow-dashboard",
 	"src/filters/bash-output-filter",
 	"src/filters/read-output-filter",
+	"src/driver/trigger-matcher",
 	"src/driver/work-loop-driver",
 ];
 
@@ -49,6 +51,13 @@ const { detectWorkflowState } = await import(
 	pathToFileURL(path.join(tempBuildDir, "src/tools/workflow-state.js"))
 );
 
+const {
+	deriveWorkflowSteps,
+	buildWorkflowDashboard,
+	buildWorkflowWidgetLines,
+	renderProgressBar,
+} = await import(pathToFileURL(path.join(tempBuildDir, "src/tools/workflow-dashboard.js")));
+
 const { filterBashOutput } = await import(
 	pathToFileURL(path.join(tempBuildDir, "src/filters/bash-output-filter.js"))
 );
@@ -61,7 +70,7 @@ const { default: workflowExtension } = await import(
 	pathToFileURL(path.join(tempBuildDir, "index.js"))
 );
 
-const { parsePlanUnits, WorkLoopDriver } = await import(
+const { parsePlanUnits, WorkLoopDriver, isExplicit03WorkTrigger } = await import(
 	pathToFileURL(path.join(tempBuildDir, "src/driver/work-loop-driver.js"))
 );
 
@@ -253,7 +262,7 @@ test("read_output_filter: compresses lockfiles and large files", () => {
 	assert.ok(r1.output.includes("totalPackagesCount"));
 });
 
-test("workflowExtension: registers tools and command cleanly", () => {
+test("workflowExtension: registers tools and command cleanly", async () => {
 	const registeredTools = new Map();
 	const registeredCommands = new Map();
 	const listeners = new Map();
@@ -280,6 +289,20 @@ test("workflowExtension: registers tools and command cleanly", () => {
 	assert.ok(listeners.has("before_agent_start"));
 	assert.ok(listeners.has("input"));
 	assert.ok(listeners.has("agent_settled"));
+
+	// Verify 00~05 shortcut transforms
+	const inputHandler = listeners.get("input");
+	const res01 = await inputHandler({ text: "01", source: "interactive" }, {});
+	assert.deepEqual(res01, { action: "transform", text: "/skill:01-brainstorm" });
+
+	const res01WithText = await inputHandler({ text: "01 补充需求边界", source: "interactive" }, {});
+	assert.deepEqual(res01WithText, { action: "transform", text: "/skill:01-brainstorm 补充需求边界" });
+
+	const res00 = await inputHandler({ text: "00", source: "interactive" }, {});
+	assert.deepEqual(res00, { action: "transform", text: "/skill:00-next" });
+
+	const resNormal = await inputHandler({ text: "1. 选第一个方案", source: "interactive" }, {});
+	assert.deepEqual(resNormal, { action: "continue" });
 });
 
 test("parsePlanUnits: correctly extracts various unit headers and check-boxes", () => {
@@ -452,3 +475,272 @@ test("WorkLoopDriver: records failure history and triggers Stop-The-Line valve o
 
 	driver.cancelTimer();
 });
+
+test("isExplicit03WorkTrigger: accurately identifies 03-work invocations vs harmless inputs", async () => {
+	// Should match explicit 03 triggers
+	assert.equal(isExplicit03WorkTrigger("/skill:03-work"), true);
+	assert.equal(isExplicit03WorkTrigger("/skill:03"), true);
+	assert.equal(isExplicit03WorkTrigger("03-work"), true);
+	assert.equal(isExplicit03WorkTrigger("03-work docs/plans/plan.md"), true);
+	assert.equal(isExplicit03WorkTrigger("03"), true);
+	assert.equal(isExplicit03WorkTrigger("/03"), true);
+	assert.equal(isExplicit03WorkTrigger("开始干活"), true);
+	assert.equal(isExplicit03WorkTrigger("开始03"), true);
+	assert.equal(isExplicit03WorkTrigger("开始实现"), true);
+	assert.equal(isExplicit03WorkTrigger("执行03"), true);
+	assert.equal(isExplicit03WorkTrigger("继续干活"), true);
+	assert.equal(isExplicit03WorkTrigger("恢复干活"), true);
+	assert.equal(isExplicit03WorkTrigger("resume work"), true);
+	assert.equal(isExplicit03WorkTrigger("【03-work 自主循环驱动引擎 · 自动化续跑指令】"), true);
+
+	// Must NEVER match other skills or normal dialogue (prevents false auto-starts!)
+	assert.equal(isExplicit03WorkTrigger("00"), false);
+	assert.equal(isExplicit03WorkTrigger("/skill:00-next"), false);
+	assert.equal(isExplicit03WorkTrigger("01"), false);
+	assert.equal(isExplicit03WorkTrigger("/skill:01-brainstorm"), false);
+	assert.equal(isExplicit03WorkTrigger("02"), false);
+	assert.equal(isExplicit03WorkTrigger("/skill:02-plan"), false);
+	assert.equal(isExplicit03WorkTrigger("04"), false);
+	assert.equal(isExplicit03WorkTrigger("/skill:04-review"), false);
+	assert.equal(isExplicit03WorkTrigger("05"), false);
+	assert.equal(isExplicit03WorkTrigger("/skill:05-learn"), false);
+	assert.equal(isExplicit03WorkTrigger("我想了解一下03步骤是什么"), false);
+	assert.equal(isExplicit03WorkTrigger("继续讨论一下需求细节"), false);
+	assert.equal(isExplicit03WorkTrigger("请帮我恢复之前被删除的代码"), false);
+	assert.equal(isExplicit03WorkTrigger(""), false);
+	assert.equal(isExplicit03WorkTrigger("   "), false);
+});
+
+test("workflow-dashboard: derives all 5 steps and renders goal-style status dashboard", async () => {
+	const mockState = {
+		repoRoot: "/test/repo",
+		hasArtifacts: true,
+		stage: "planned",
+		recommendedSkill: "03-work",
+		recommendationReason: "计划已就绪",
+		brainstorms: [{ filename: "requirements.md", relativePath: "docs/brainstorms/requirements.md", mtimeMs: 100 }],
+		plans: [{ filename: "plan.md", relativePath: "docs/plans/plan.md", mtimeMs: 200 }],
+		solutions: [],
+		checkpoints: [],
+		latestBrainstorm: { filename: "requirements.md", relativePath: "docs/brainstorms/requirements.md", mtimeMs: 100 },
+		latestPlan: { filename: "plan.md", relativePath: "docs/plans/plan.md", mtimeMs: 200 },
+		totalUnitsCount: 4,
+		completedUnitsCount: 1,
+		remainingUnitsCount: 3,
+		nextUnitId: "Unit 1",
+	};
+
+	const mockWorkStatus = {
+		isActive: true,
+		planPath: "/test/repo/docs/plans/plan.md",
+		planSlug: "plan",
+		allUnits: ["Unit 0", "Unit 1", "Unit 2", "Unit 3"],
+		completedUnits: ["Unit 0"],
+		remainingUnits: ["Unit 1", "Unit 2", "Unit 3"],
+		currentUnit: "Unit 1",
+		failedUnit: null,
+		consecutiveFailures: 0,
+		currentRunCount: 1,
+		maxRuns: 50,
+	};
+
+	// 1. Check all 5 steps derivation
+	const steps = deriveWorkflowSteps(mockState, mockWorkStatus);
+	assert.equal(steps.length, 5);
+	assert.equal(steps[0].number, "01");
+	assert.equal(steps[0].id, "01-brainstorm");
+	assert.equal(steps[0].status, "completed");
+
+	assert.equal(steps[1].number, "02");
+	assert.equal(steps[1].id, "02-plan");
+	assert.equal(steps[1].status, "completed");
+
+	assert.equal(steps[2].number, "03");
+	assert.equal(steps[2].id, "03-work");
+	assert.equal(steps[2].status, "in_progress");
+	assert.equal(steps[2].isCurrent, true);
+
+	assert.equal(steps[3].number, "04");
+	assert.equal(steps[3].id, "04-review");
+
+	assert.equal(steps[4].number, "05");
+	assert.equal(steps[4].id, "05-learn");
+
+	// 2. Check full dashboard rendering
+	const dashboard = buildWorkflowDashboard(mockState, mockWorkStatus);
+	assert.ok(dashboard.includes("Workflow Dashboard"));
+	assert.ok(dashboard.includes("▶ [03] 03-work"));
+	assert.ok(dashboard.includes("[01] 01-brainstorm"));
+	assert.ok(dashboard.includes("[02] 02-plan"));
+	assert.ok(dashboard.includes("[04] 04-review"));
+	assert.ok(dashboard.includes("[05] 05-learn"));
+	assert.ok(dashboard.includes("Esc/Ctrl+C"));
+	assert.ok(dashboard.includes("单元进度:"));
+
+	// 3. Check progress bar helper
+	assert.equal(renderProgressBar(2, 4, 8), "████░░░░");
+	assert.equal(renderProgressBar(4, 4, 8), "████████");
+	assert.equal(renderProgressBar(0, 4, 8), "░░░░░░░░");
+
+	// 4. Check widget lines
+	const widgetLines = buildWorkflowWidgetLines(mockState, mockWorkStatus);
+	assert.ok(widgetLines[0].includes("03-work"));
+	assert.ok(widgetLines[0].includes("Unit 1"));
+});
+
+test("WorkLoopDriver: Esc/Abort interruption safely disarms autonomous driving", async () => {
+	const testRoot = path.join(tempBuildDir, "loop-interrupt-test-" + Date.now());
+	const plansDir = path.join(testRoot, "docs", "plans");
+	await mkdir(plansDir, { recursive: true });
+
+	const planFile = path.join(plansDir, "interrupt-plan.md");
+	await writeFile(planFile, "# Plan\n### Unit 0 — Alpha\n### Unit 1 — Beta", "utf-8");
+
+	const driver = new WorkLoopDriver(testRoot);
+	await driver.start(planFile);
+	assert.equal(driver.getStatus().isActive, true);
+
+	// 1. Simulate pause triggered by Esc / user action
+	await driver.pause("用户按 Esc 中断");
+	assert.equal(driver.getStatus().isActive, false);
+	assert.ok(driver.getStatus().lastMessage.includes("用户按 Esc 中断"));
+
+	// 2. Simulate agent_settled called while paused -> must NOT start next turn
+	let sendCalled = false;
+	const mockPi = {
+		sendUserMessage() {
+			sendCalled = true;
+		},
+	};
+	const mockCtx = {
+		signal: undefined,
+		ui: { notify() {}, setStatus() {} },
+	};
+	await driver.onAgentSettled(mockCtx, mockPi);
+	assert.equal(sendCalled, false);
+	assert.equal(driver.getStatus().isActive, false);
+
+	// 3. Test onAgentSettled with ctx.signal.aborted
+	await driver.start(planFile);
+	assert.equal(driver.getStatus().isActive, true);
+	const abortedCtx = {
+		signal: { aborted: true },
+		ui: { notify() {}, setStatus() {} },
+	};
+	await driver.onAgentSettled(abortedCtx, mockPi);
+	assert.equal(driver.getStatus().isActive, false);
+	assert.equal(sendCalled, false);
+
+	// 4. Test onAgentSettled with last assistant message aborted (Ctrl+C / Esc aftermath)
+	await driver.start(planFile);
+	assert.equal(driver.getStatus().isActive, true);
+	const sessionAbortedCtx = {
+		signal: undefined,
+		sessionManager: {
+			getBranch() {
+				return [
+					{ type: "message", message: { role: "user", content: "hello" } },
+					{ type: "message", message: { role: "assistant", stopReason: "aborted", content: "stopping..." } },
+				];
+			},
+		},
+		ui: { notify() {}, setStatus() {} },
+	};
+	await driver.onAgentSettled(sessionAbortedCtx, mockPi);
+	assert.equal(driver.getStatus().isActive, false);
+	assert.equal(sendCalled, false);
+	assert.ok(driver.getStatus().lastMessage.includes("中断"));
+});
+
+test("E2E Lifecycle: 01 brainstorm -> 02 plan -> 01 rollback -> 03 work -> compact dashboard & widget", async () => {
+	const testRoot = path.join(tempBuildDir, "e2e-workflow-" + Date.now());
+	const brainstormsDir = path.join(testRoot, "docs", "brainstorms");
+	const plansDir = path.join(testRoot, "docs", "plans");
+	await mkdir(brainstormsDir, { recursive: true });
+	await mkdir(plansDir, { recursive: true });
+
+	// 1. Initial State: No artifacts -> recommends 01-brainstorm
+	let state = await detectWorkflowState(testRoot);
+	assert.equal(state.recommendedSkill, "01-brainstorm");
+
+	// 2. User creates 01 brainstorm artifact
+	const bsFile = path.join(brainstormsDir, "2026-09-18-auth-requirements.md");
+	await writeFile(bsFile, "# Auth Requirements\nScope: login, register", "utf-8");
+
+	state = await detectWorkflowState(testRoot);
+	assert.equal(state.recommendedSkill, "02-plan");
+	assert.equal(state.brainstorms.length, 1);
+
+	// 3. User creates 02 plan artifact
+	const planFile = path.join(plansDir, "2026-09-18-auth-plan.md");
+	await writeFile(
+		planFile,
+		"# Auth Plan\n### Unit 0 — DB Schema\n### Unit 1 — API Route\n### Unit 2 — Tests",
+		"utf-8",
+	);
+
+	state = await detectWorkflowState(testRoot);
+	assert.equal(state.recommendedSkill, "03-work");
+	assert.equal(state.totalUnitsCount, 3);
+
+	// 4. User is in 02, realizes requirements need changes -> Rolls back to 01!
+	// (Simulate input event transform)
+	const listeners = new Map();
+	const mockPi = {
+		registerTool() {},
+		registerCommand() {},
+		on(event, handler) {
+			listeners.set(event, handler);
+		},
+	};
+	workflowExtension(mockPi);
+	const inputHandler = listeners.get("input");
+
+	// User types "01 增加第三方登录"
+	const transformRes = await inputHandler({ text: "01 增加第三方登录", source: "interactive" }, {});
+	assert.deepEqual(transformRes, {
+		action: "transform",
+		text: "/skill:01-brainstorm 增加第三方登录",
+	});
+
+	// User updates brainstorm file
+	await writeFile(bsFile, "# Auth Requirements\nScope: login, register, oauth2", "utf-8");
+
+	// 5. User returns to 02
+	const returnTo02 = await inputHandler({ text: "02", source: "interactive" }, {});
+	assert.deepEqual(returnTo02, {
+		action: "transform",
+		text: "/skill:02-plan",
+	});
+
+	// 6. User enters 03 -> starts autonomous work
+	const driver = new WorkLoopDriver(testRoot);
+	const startRes = await driver.start(planFile);
+	assert.equal(startRes.success, true);
+	assert.equal(startRes.status.isActive, true);
+
+	// 7. Verify Dashboard height is strictly 7 lines
+	const dashboard = buildWorkflowDashboard(state, driver.getStatus());
+	const dashboardLines = dashboard.trim().split("\n");
+	assert.equal(dashboardLines.length, 7, "Dashboard must strictly occupy exactly 7 lines");
+	assert.ok(dashboard.includes("▶ [03] 03-work"));
+	assert.ok(dashboard.includes("✓ [01] 01-brainstorm"));
+	assert.ok(dashboard.includes("✓ [02] 02-plan"));
+
+	// 8. Verify Widget height is strictly 1 line
+	const widgetLines = buildWorkflowWidgetLines(state, driver.getStatus());
+	assert.equal(widgetLines.length, 1, "Widget must strictly occupy exactly 1 line");
+	assert.ok(widgetLines[0].includes("03-work"));
+	assert.ok(widgetLines[0].includes("01✓ 02✓ 03▶"));
+
+	// 9. Manual interruption (Esc) stops the loop
+	await driver.pause("User hit Esc");
+	assert.equal(driver.getStatus().isActive, false);
+
+	// Post-pause widget is also strictly 1 line
+	const pausedWidgetLines = buildWorkflowWidgetLines(state, driver.getStatus());
+	assert.equal(pausedWidgetLines.length, 1);
+	assert.ok(pausedWidgetLines[0].includes("已暂停"));
+});
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unifan/pi-unifan-zh",
-  "version": "1.0.35",
+  "version": "1.0.37",
   "description": "Pi Coding Agent 中文扩展全家桶与独立插件集",
   "type": "module",
   "main": "extensions/sessions/index.ts",