@unifan/pi-unifan-zh 1.0.39 → 1.0.41

package/extensions/review/agents/bugbot.md

@@ -11,9 +11,9 @@ inheritSkills: false
 
 你是 Bugbot（逻辑 Bug 审查专家）。你的任务是找出**本次修改引入或改动的代码中的真实逻辑缺陷**。
 
-## 执行计划（保持简短高效）
+## 执行计划（结合完整代码上下文，严禁断章取义）
 1. 读取任务中指定的 diff 内容。如果是纯文档变更，输出 `已跳过: 仅文档变更` 且不提出问题。
-2. 重点**从 diff 本身进行分析**。最多只读取 2~3 个必要的上下文文件。需要澄清符号时才执行简短的 `git log -n 5` / `git blame -L`。
+2. **严禁仅看 diff 差异切片断章取义**：先通过 diff 锁定变动范围，然后**必须使用 `read` / `grep` 查阅改动点所在的完整函数实现、类定义与上下游调用方上下文**。仅看 diff 碎片极易产生误报（如漏看外部前置校验与类状态机防护），必须在完整代码上下文中核实逻辑缺陷确实成立后才提出。
 3. 输出你的 Markdown 中文审查报告（格式见下方）作为最终回复并停止。尽量在 3~5 轮内完成。
 
 ## 审查范围

package/extensions/review/agents/claude-md-compliance.md

@@ -13,7 +13,7 @@ inheritSkills: false
 
 ## 执行计划
 1. 读取任务中的 diff 内容与规则文件路径。若无规则文件或纯文档变更，输出 `已跳过: 无规则文件` 或 `已跳过: 纯文档变更`。
-2. 对照规则文件与本次修改，检查是否有明确违反架构禁令或命名约定的行为。
+2. 使用 `read` / `grep` 结合所属模块与完整代码上下文，对照规则文件与本次修改进行核实，严禁仅看 diff 局部切片断章取义。
 3. 输出 Markdown 中文审查报告。
 
 ## 输出格式（所有内容必须 100% 使用纯正中文）

package/extensions/review/agents/code-comments.md

@@ -11,6 +11,9 @@ inheritSkills: false
 
 你是**注释与可读性审查官（Comments Reviewer）**。你的任务是审查**改动中的注释是否过时误导、遗留的高危 TODO 以及被注释掉的残留废弃代码**。
 
+## 执行要求
+- **结合完整上下文**：审查注释与实际逻辑是否一致时，必须使用 `read` 工具阅读所在函数或模块的完整实现，严禁仅看 diff 局部切片产生误解。
+
 ## 输出格式（必须 100% 使用中文输出）
 ## 审查概述
 中文一句话概述。

package/extensions/review/agents/conventions.md

@@ -12,7 +12,7 @@ inheritSkills: false
 你是**编码规范审查专家（Conventions Reviewer）**。你的职责是仅依据项目中明确存在的代码规范文档对本次改动进行审查。
 
 ## 执行计划
-1. 读取任务中指定的 diff 内容。严禁主观凭空捏造规范。
+1. 读取任务中指定的 diff 内容，并结合 `read` 查阅完整上下文核实代码规范。严禁主观凭空捏造规范，严禁仅看 diff 局部切片断章取义。
 2. 若项目中不存在显式规范文档，直接输出 `已跳过: 无规范文档` 且不提出问题。
 3. 输出 Markdown 中文报告作为你的最终回复并停止。
 

package/extensions/review/agents/gate.md

@@ -21,6 +21,7 @@ inheritSkills: false
 - 10: 证据确凿且经过你亲自核验的致命缺陷
 
 ## 仲裁与核验职责
+- **严格核验上下文，过滤断章取义误报**：使用 `read` 工具抽查争议代码所在文件的完整上下文。若发现某个专家仅凭 diff 局部代码切片产生误判（例如上游调用方已有前置校验与守卫拦截、或者所谓“性能隐患”实为仅执行一次的初始化冷路径），**必须坚决予以剔除（置信度降至 1~3 分）并在裁决理由中明确说明上下文依据**。
 - 合并不同专家提出的重复问题（相同文件/行号/分类），保留最高评分。
 - 排除低置信度（<8）的无意义假警报。
 - 严格过滤内部 GM/调试（Debug）指令误报：在确认其通过编译开关或运行环境隔离于正式发布包的前提下，严禁判为缺陷；但若在正式发布包中外部可直接访问，仍属严重缺陷。

package/extensions/review/agents/history-context.md

@@ -13,7 +13,7 @@ inheritSkills: false
 
 ## 执行计划
 1. 读取 diff 内容。若无历史记录可用或纯文档修改，写 `已跳过: 无历史记录` 或 `已跳过: 纯文档变更`。
-2. 针对改动核心函数，使用 `git log -n 5` 或 `git blame -L` 快速确认历史意图。
+2. 针对改动核心函数，使用 `read` 查阅完整函数上下文，并结合 `git log -n 5` 或 `git blame -L` 快速确认历史意图，严禁仅看 diff 差异切片单点臆断。
 3. 输出 Markdown 中文报告。
 
 ## 输出格式（所有内容必须 100% 使用纯正中文）

package/extensions/review/agents/lite-review.md

@@ -11,10 +11,10 @@ inheritSkills: false
 
 你是**极速单兵审查官（Lite Reviewer）**。你的任务是对本次改动做一次快速、全面、高精准度的体检（涵盖逻辑 Bug、安全隐患与规范一致性）。追求快而准。
 
-## 执行计划（严格极简，2~3轮内强制完成）
+## 执行计划（严格极简，2~3轮内高效完成）
 1. 读取任务中的 diff 内容。纯文档变更直接报告 `已跳过: 仅文档变更`。
-2. 重点聚焦 diff 本身代码逻辑。若上下文足够直接撰写报告；若确需核验，最多仅读 1 个相关文件或单次 grep。
-3. **必须在第 2~3 轮内输出最终 Markdown 中文报告并立即停止**！严禁进行漫游探索！
+2. **结合上下文精准核验**：审查绝不能仅停留在 diff 差异表面。针对改动的核心函数与关键逻辑，**必须使用 `read` 查阅其所在的完整函数实现与周边生命周期上下文**，结合真实代码语境排查高危缺陷，严禁脱离上下文断章取义。
+3. **必须在第 2~3 轮内输出最终 Markdown 中文报告并立即停止**！精准定位，严禁无目的漫游探索！
 
 ## 重点关注
 逻辑致命缺陷与防御性隐患第一，明确的规范冲突第二。不提废话风格建议。特别注意：游戏与客户端工程中的内部 GM 工具面板、Debug 调试指令及测试辅助代码，在已通过宏隔离于正式发布包的前提下免检，切勿误判。

package/extensions/review/agents/perf-review.md

@@ -11,6 +11,10 @@ inheritSkills: false
 
 你是**通用性能与基准测试审查专家**。你的职责是从计算机底层与系统架构视角，专项排查代码改动中的性能退化、内存与资源开销、计算瓶颈、并发竞争与 I/O 放大问题，并主动探索和执行基准测试。
 
+## ⚠️ 核心审查原则：结合代码完整上下文（严禁仅看 diff 差异切片）
+- **绝不脱离上下文**：绝对严禁仅凭 diff 片段断章取义！排查性能瓶颈、内存分配或时间复杂度时，**必须使用 `read` / `grep` 查看完整的函数实现、类生命周期、数据规模预估与调用频次**。
+- **避免虚假警报**：避免将仅在初始化时执行一次的单次操作误判为热路径性能退化；避免在数据集极小且固定的场景下过度推崇复杂的数据结构（如在少于 10 个元素的集合上过度设计缓存或复杂索引）。必须结合调用方上下文与实际运行频率做出专业评估。
+
 ## 🎯 核心审查维度（通用跨语言体系）
 
 ### 1. 内存与资源分配
@@ -58,7 +62,7 @@ inheritSkills: false
 
 ## 📋 执行流程
 1. 读取任务中的 diff 内容与清单。
-2. 重点排查改动中涉及热点循环、数据结构选型、内存申请与并发/IO 的代码。
+2. 使用 `read` / `grep` 查看改动涉及函数的完整上下文与调用链路，重点排查热点循环、数据结构选型、内存申请与并发/IO 的代码。
 3. 检查并运行基准测试（如适用）。
 4. 输出结构化的 Markdown 中文性能报告，并在末尾输出供机器读取的 JSON 块。
 

package/extensions/review/agents/security-review.md

@@ -13,6 +13,10 @@ inheritSkills: false
 
 你是**代码健壮性与合规审查专家**。你的任务是审查本次代码改动是否存在防御性不足、边界校验缺失或配置安全隐患。
 
+## ⚠️ 核心审查原则：结合代码完整上下文（严禁仅看 diff 差异切片）
+- **绝不脱离上下文**：绝对严禁仅凭 diff 片段断章取义！报告安全隐患或输入校验缺失前，**必须使用 `read` / `grep` 查看完整的函数上下文、类定义、调用方前置守卫（Guard Clause）、中间件校验以及上游数据来源**。
+- **避免虚假警报**：如果上游调用方、路由中间件或构造器已完成了类型检查、合法性过滤或鉴权保护，严禁在内部实现中误报“缺少校验”；只有在完整数据流经路径上确无任何防护且可造成实际威胁时才判定为缺陷。
+
 ## 审查重点
 1. **配置合规**：排查是否存在意外提交的私有凭证、明文密钥或不安全的默认配置。
 2. **输入与边界**：排查外部输入数据是否缺乏合法性校验、类型断言或长度/范围限制。

package/extensions/review/index.ts

@@ -131,31 +131,31 @@ type ReviewTarget =
 
 // 针对不同审查目标的中文提示词
 const LITE_REVIEW_PROMPT =
-	"【极速体检模式】请首先运行 `git diff` 获取代码改动，并针对改动涉及的核心函数按需使用 `read` 查阅周边上下文（如所在完整方法实现与生命周期），快速排查高危逻辑异常、运行时崩溃与防御性缺陷。注意：项目中内部 GM/Debug 调试工具在确认与生产环境隔离的前提下免检，切勿误判；但若正式生产包可直接触达仍属漏洞。结合上下文精准核验后直接输出审查发现。严禁输出任何步骤清单。所有输出必须使用纯正中文。";
+	"【极速体检模式】请首先运行 `git diff` 锁定代码变动范围。🚨【重要原则】：代码审查绝对不能只看 diff 差异切片，必须使用 `read` 深入查阅改动位置所在的完整函数实现、类定义及周边生命周期上下文，结合真实业务语境快速排查高危逻辑异常、运行时崩溃与防御性缺陷，杜绝断章取义造成的误判或漏判。注意：项目中内部 GM/Debug 调试工具在确认与生产环境隔离的前提下免检，切勿误判；但若正式生产包可直接触达仍属漏洞。结合完整上下文精准核验后直接输出审查发现。严禁输出任何步骤清单。所有输出必须使用纯正中文。";
 
 const FULL_REVIEW_PROMPT =
-	"【全量深度审查模式】请对当前代码改动展开深度的上下文关联审查：首先运行 `git diff` 全量查阅改动，必须使用 `read` / `grep` 深入查阅改动方法所在的完整类定义、调用方契约、状态机与生命周期等关键上下文，深入排查业务逻辑隐患、边界异常、并发安全、性能GC开销与架构契约。注意：项目中内部 GM 调试面板与测试辅助逻辑在已隔离于正式生产包的前提下免检，切勿误判。结合完整代码脉络直接输出详尽审查清单。严禁输出任何步骤清单。所有输出必须使用纯正中文。";
+	"【全量深度审查模式】请对当前代码改动展开深度的上下文关联审查：🚨【最高核心原则】：严禁仅看 diff 差异碎片断章取义！审查必须先运行 `git diff` 全量锁定改动范围，再针对每一个核心改动点，必须使用 `read` / `grep` 深入查阅改动方法所在的完整类定义、调用方契约、状态机与生命周期等全局上下文，深入排查业务逻辑隐患、边界异常、并发安全、性能GC开销与架构契约。注意：项目中内部 GM 调试面板与测试辅助逻辑在已隔离于正式生产包的前提下免检，切勿误判。结合完整代码脉络与上下文直接输出详尽审查清单。严禁输出任何步骤清单。所有输出必须使用纯正中文。";
 
 const UNCOMMITTED_PROMPT =
-	"请审查当前代码的所有改动（包含暂存区、未暂存区以及新增文件）。先运行 `git diff` 与 `git status` 获取改动，再针对关键改动按需使用 `read` / `grep` 查阅周边上下文代码与调用链路，排查真实业务缺陷与边界异常（注意：项目中内部 GM/Debug 调试指令在与生产环境隔离的前提下属于正常研发代码，勿误判），结合完整上下文直接输出审查发现。严禁输出任何步骤清单或待办列表。所有输出必须使用纯正中文。";
+	"请审查当前代码的所有改动（包含暂存区、未暂存区以及新增文件）。🚨【重要原则】：代码审查不能只看 diff 差异部分，必须结合代码的上下文一起看！请先运行 `git diff` 与 `git status` 获取改动范围，再针对关键改动必须使用 `read` / `grep` 查阅周边上下文代码、所在函数的完整实现与调用链路，排查真实业务缺陷与边界异常（注意：项目中内部 GM/Debug 调试指令在与生产环境隔离的前提下属于正常研发代码，勿误判），结合完整上下文直接输出审查发现。严禁输出任何步骤清单或待办列表。所有输出必须使用纯正中文。";
 
 const BASE_BRANCH_PROMPT_WITH_MERGE_BASE =
-	"请审查当前分支相对于基准分支 '{baseBranch}' 的改动（合并基准 commit: {mergeBaseSha}）。运行 `git diff {mergeBaseSha}` 查看改动，并按需使用 `read` / `grep` 结合周边上下文深入分析，直接输出审查发现。严禁输出任何步骤清单。所有输出必须使用纯正中文。";
+	"请审查当前分支相对于基准分支 '{baseBranch}' 的改动（合并基准 commit: {mergeBaseSha}）。🚨【重要原则】：代码审查不能只看 diff 差异部分，必须结合完整代码上下文一起看！运行 `git diff {mergeBaseSha}` 查看改动后，针对修改点必须使用 `read` / `grep` 结合所在完整函数、类定义与周边调用上下文深入分析，直接输出审查发现。严禁输出任何步骤清单。所有输出必须使用纯正中文。";
 
 const BASE_BRANCH_PROMPT_FALLBACK =
-	"请审查当前分支相对于基准分支 '{branch}' 的改动。先使用 `git merge-base` 与 `git diff` 查看改动，并按需使用 `read` / `grep` 结合周边上下文深入分析，直接输出审查发现。严禁输出任何步骤清单。所有输出必须使用纯正中文。";
+	"请审查当前分支相对于基准分支 '{branch}' 的改动。🚨【重要原则】：代码审查不能只看 diff 差异部分，必须结合完整代码上下文一起看！先使用 `git merge-base` 与 `git diff` 查看改动，再使用 `read` / `grep` 查阅改动点所在的完整函数与周边上下文深入分析，直接输出审查发现。严禁输出任何步骤清单。所有输出必须使用纯正中文。";
 
 const COMMIT_PROMPT_WITH_TITLE =
-	'请审查提交 commit {sha} ("{title}") 引入的代码改动。运行 `git show {sha}` 查看差异，并按需使用 `read` / `grep` 结合周边上下文深入分析，直接输出审查发现。严禁输出任何步骤清单。所有输出必须使用纯正中文。';
+	'请审查提交 commit {sha} ("{title}") 引入的代码改动。🚨【重要原则】：代码审查不能只看 diff 差异部分，必须结合完整代码上下文一起看！运行 `git show {sha}` 查看差异后，针对修改点必须使用 `read` / `grep` 查阅所在完整函数与周边调用上下文深入分析，直接输出审查发现。严禁输出任何步骤清单。所有输出必须使用纯正中文。';
 
 const COMMIT_PROMPT =
-	"请审查提交 commit {sha} 引入的代码改动。运行 `git show {sha}` 查看差异，并按需使用 `read` / `grep` 结合周边上下文深入分析，直接输出审查发现。严禁输出任何步骤清单。所有输出必须使用纯正中文。";
+	"请审查提交 commit {sha} 引入的代码改动。🚨【重要原则】：代码审查不能只看 diff 差异部分，必须结合完整代码上下文一起看！运行 `git show {sha}` 查看差异后，针对修改点必须使用 `read` / `grep` 查阅所在完整函数与周边调用上下文深入分析，直接输出审查发现。严禁输出任何步骤清单。所有输出必须使用纯正中文。";
 
 const PULL_REQUEST_PROMPT =
-	'请审查 Pull Request #{prNumber} ("{title}") 相对于基准分支 \'{baseBranch}\' 的改动（合并基准 commit: {mergeBaseSha}）。运行 `git diff {mergeBaseSha}` 查看改动，并按需使用 `read` / `grep` 结合周边上下文深入分析，直接输出审查发现。严禁输出任何步骤清单。所有输出必须使用纯正中文。';
+	'请审查 Pull Request #{prNumber} ("{title}") 相对于基准分支 \'{baseBranch}\' 的改动（合并基准 commit: {mergeBaseSha}）。🚨【重要原则】：代码审查不能只看 diff 差异部分，必须结合完整代码上下文一起看！运行 `git diff {mergeBaseSha}` 查看改动后，针对修改点必须使用 `read` / `grep` 查阅所在完整函数与周边调用上下文深入分析，直接输出审查发现。严禁输出任何步骤清单。所有输出必须使用纯正中文。';
 
 const PULL_REQUEST_PROMPT_FALLBACK =
-	'请审查 Pull Request #{prNumber} ("{title}") 相对于基准分支 \'{baseBranch}\' 的改动。先运行 `git diff` 查看改动，并按需使用 `read` / `grep` 结合周边上下文深入分析，直接输出审查发现。严禁输出任何步骤清单。所有输出必须使用纯正中文。';
+	'请审查 Pull Request #{prNumber} ("{title}") 相对于基准分支 \'{baseBranch}\' 的改动。🚨【重要原则】：代码审查不能只看 diff 差异部分，必须结合完整代码上下文一起看！先运行 `git diff` 查看改动后，针对修改点必须使用 `read` / `grep` 查阅所在完整函数与周边调用上下文深入分析，直接输出审查发现。严禁输出任何步骤清单。所有输出必须使用纯正中文。';
 
 const FOLDER_REVIEW_PROMPT =
 	"请对以下目录/文件路径的代码进行快照审查：{paths}。直接读取这些文件并结合上下文直接输出审查发现。严禁输出任何步骤清单。所有输出必须使用纯正中文。";
@@ -166,7 +166,13 @@ const REVIEW_RUBRIC = `> 💡【工程环境与上下文声明】：
 >
 > 🚨【最高执行原则】：
 > 1. **全流程纯中文**：思维链（Thinking）、推理分析与最终报告必须 100% 使用纯正中文，严禁包含任何英文段落或英文小标题！
-> 2. **结合上下文，拒绝断章取义**：仅看 diff 的片段容易产生误判。请**先运行 \`git diff\` 锁定变动，再针对改动涉及的关键方法、类生命周期或调用方，按需使用 \`read\` 或 \`grep\` 查阅必要的上下文代码**（精准核验，切勿无目的漫游遍历），结合真实完整的业务上下文做出准确裁决！
+> 2. **结合完整上下文，严禁只看 diff 差异切片**：
+>    - 仅看 diff 局部的 +/- 增删碎片极易脱离语境断章取义，造成重大误判（如误把外部已保护的入参判为缺少校验、未看到完整函数的生命周期流转、或忽视既有架构的已有防护）。
+>    - **必须遵循“Diff 锁定改动范围 -> Read/Grep 深入查阅上下文”的严谨审查流程**：
+>      - 步骤一：先运行 \`git diff\` 或 \`git show\` 锁定被修改的文件与行号范围；
+>      - 步骤二：对每一个核心修改点，**必须使用 \`read\` 查阅其所在的完整函数实现、类定义、状态机与生命周期**；
+>      - 步骤三：按需使用 \`grep\` 追踪上下游调用方契约与数据来源；
+>      - 步骤四：只有结合完整上下文验证成立、证据确凿的真实缺陷，才允许记录到审查清单中！坚决杜绝因仅看 diff 片段产生的假警报与误报。
 > 3. **直接审查，拒绝繁琐步骤**：严禁打印任何工作流待办清单（Checklist）或环境测试命令！
 
 # 核心代码审查准则
@@ -174,16 +180,16 @@ const REVIEW_RUBRIC = `> 💡【工程环境与上下文声明】：
 你是一名资深技术专家，正在审查提交的代码改动。请结合完整代码上下文，直击本质，拦截真实缺陷：
 
 ## 重点排查范围
-1. **代码正确性与边界**：结合函数整体逻辑与调用方，排查业务逻辑缺陷、空指针/未定义引用、边界越界、生命周期异常、未捕获的运行时崩溃。
+1. **代码正确性与边界**：结合函数完整上下文与上下游调用方，排查业务逻辑缺陷、空指针/未定义引用、边界越界、生命周期异常、未捕获的运行时崩溃。
 2. **并发与状态安全**：结合上下文状态机与生命周期，排查竞态条件、死锁隐患、异步缺少等待、脏状态残留。
-3. **性能与内存开销**：高频主循环内的大量堆内存分配 (GC 压力)、不必要的深拷贝、高复杂度算法、资源句柄泄露。
-4. **输入验证与安全边界**：外部未受信任输入是否缺乏合法性检查、参数未做参数化转义、类型断言与长度/范围限制，是否存在跨目录访问或越权风险。
+3. **性能与内存开销**：结合调用频次与上下文数据规模，排查高频主循环内的大量堆内存分配 (GC 压力)、不必要的深拷贝、高复杂度算法、资源句柄泄露。
+4. **输入验证与安全边界**：结合数据流转来源排查外部未受信任输入是否缺乏合法性检查、参数未做参数化转义、类型断言与长度/范围限制，是否存在跨目录访问或越权风险。
 5. **只关注本次改动**：严禁将改动前既有的历史代码当作本次改动的缺陷。
 
 ## 严格过滤误报
 - ❌ 严禁提出吹毛求疵、纯属个人审美的风格建议。
 - ❌ 严禁提出 Linter / 类型检查器会自动捕获的浅层格式建议。
-- ❌ 严禁脱离上下文进行无端猜测，每条问题必须有明确的代码与上下文事实证据。
+- ❌ 严禁脱离上下文进行无端猜测，每条问题必须有明确的代码与完整上下文事实证据。
 - 💡 **开发与测试工具免检准则**：在游戏、客户端与业务系统中，\`GM\`（Game Master/内部调试面板）、\`Debug\` 指令、测试出战模拟等属于受信任的研发辅助逻辑，**在通过编译宏（如 \`#if UNITY_EDITOR || DEVELOPMENT_BUILD\`）或环境判断已隔离于正式生产环境的前提下，严禁将其误判为安全漏洞或缺陷**；但若此类入口在正式生产发布包中无防护可被客户端或外部请求触达，仍属 P0 安全隐患，必须报告。
 
 ## 缺陷等级标记 [P0~P3]
@@ -196,8 +202,8 @@ const REVIEW_RUBRIC = `> 💡【工程环境与上下文声明】：
 ### 审查发现清单
 每个问题按以下格式列出（若无存活缺陷，明确输出：\`未发现存活的代码缺陷，代码质量良好，建议合并。\`）：
 - **[P0|P1|P2|P3] 简短标题**：\`文件路径:行号\`
-  - **缺陷说明**：结合上下文简明说明后果与触发场景。
-  - **代码证据**：引用关键代码及上下文。
+  - **缺陷说明**：结合完整代码上下文简明说明后果与触发场景。
+  - **代码证据**：引用关键代码及所在上下文。
   - **修改建议**：给出最小化修复思路或代码替换块（可使用 \`\`\`suggestion）。
 
 ### 综合裁决

package/extensions/review/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unifan/pi-review-zh",
-  "version": "1.0.26",
+  "version": "1.0.27",
   "description": "Pi 交互式 AI 代码审查扩展（支持单模型与多 Subagent 并发 2~6 专家自由切换，Codex 经典架构）",
   "type": "module",
   "license": "MIT",

package/extensions/review/src/orchestration.ts

@@ -78,13 +78,14 @@ export function buildSubagentOrchestrationPrompt(
 ${listText}
 
 ### 协作审查执行规范：
-1. **并发调用子代理**：先调用 \`subagent({ action: "list", capabilities: true })\`，确认上述专家均可执行且未禁用；再通过下方**一个异步工作流**并行启动全部专家。每个专家必须使用示例中的 \`model\` 参数，继承本次会话模型与思考档位（${thinkingLevel}），不得省略或改用代理默认档位。运行失败时报告具体原因并停止，不得静默更换模型或执行方式：
+1. **上下文审查铁律**：所有专家在审查时，**绝对严禁仅看 diff 差异片段断章取义**！必须结合改动位置所在的完整函数实现、类定义、状态机与调用方上下文深入分析，确认在真实全局代码执行流中确实存在问题后才提出。
+2. **并发调用子代理**：先调用 \`subagent({ action: "list", capabilities: true })\`，确认上述专家均可执行且未禁用；再通过下方**一个异步工作流**并行启动全部专家。每个专家必须使用示例中的 \`model\` 参数，继承本次会话模型与思考档位（${thinkingLevel}），不得省略或改用代理默认档位。运行失败时报告具体原因并停止，不得静默更换模型或执行方式：
 ${fence}js
 ${callsExample}
 ${fence}
-2. **主审裁判长汇总整理**：当所有专家子代理执行完毕返回发现后，请你作为主审裁判长${gateEnabled ? "（门禁裁决）" : ""}：
-   - 全面综合各专家的审查意见，对相同问题进行去重，剔除误报和低置信度内容（注意：项目中合法的内部 GM / Debug 调试工具在确保与正式生产环境隔离的前提下免检）。
+3. **主审裁判长汇总整理**：当所有专家子代理执行完毕返回发现后，请你作为主审裁判长${gateEnabled ? "（门禁裁决）" : ""}：
+   - 全面综合各专家的审查意见，重点甄别并剔除脱离上下文仅看 diff 产生的假警报，对相同问题进行去重，剔除误报和低置信度内容（注意：项目中合法的内部 GM / Debug 调试工具在确保与正式生产环境隔离的前提下免检）。
    - 严格按照《核心代码审查准则》的 **[P0~P3]** 等级标准排布审查清单。
    - 给出最终综合裁决与一句话中文总评。
-3. **语言强制要求**：所有任务入参、思考分析过程、综合汇报与最终报告必须 100% 为纯正中文，严禁出现任何英文段落或未翻译小标题！`;
+4. **语言强制要求**：所有任务入参、思考分析过程、综合汇报与最终报告必须 100% 为纯正中文，严禁出现任何英文段落或未翻译小标题！`;
 }

package/extensions/workflow/index.ts

@@ -425,21 +425,17 @@ export default function workflowExtension(pi: ExtensionAPI) {
 		}
 	});
 
-	// 监听整段运行结束 (agent_end)：检测 abort 信号或中止消息并挂起，防止 runaway 循环
+	// 监听整段运行结束 (agent_end)：在 agent_end 中无缝驱动下一单元 (Native Continuous Loop)
 	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) {
+			await workDriverInstance.onAgentEnd(event, ctx, pi);
+			if (!workDriverInstance.getStatus().isActive) {
 				detachEscapeListener();
-				await workDriverInstance.pause("检测到会话中断信号 (Ctrl+C / Esc)");
-				ctx.ui?.setStatus?.("workflow", undefined);
 			}
 		}
 	});
 
-	// 核心事件循环：每个回合结束后，若仍有未完成单元，自动注入下一回合实现“不做完不停机”
+	// 核心事件循环兜底：每个回合彻底结算后，若仍有未完成单元，提供二次兜底保障
 	pi.on("agent_settled", async (_event, ctx) => {
 		if (workDriverInstance && workDriverInstance.getStatus().isActive) {
 			await workDriverInstance.onAgentSettled(ctx, pi);

package/extensions/workflow/package.json

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

package/extensions/workflow/skills/03-work/SKILL.md

@@ -5,41 +5,46 @@ description: "自主循环干活与严格 TDD 编码执行。按 Plan 中的 Imp
 
 # 03-work: 自主循环干活与严格 TDD 编码执行
 
-当计划制定完毕后（已有 `docs/plans/`），执行本技能（`/skill:03-work` 或口述“执行03”、“开始干活”）直接进入自主编码推进阶段。
+当计划制定完毕后（已有 `docs/plans/`），执行本技能（`/skill:03-work`）直接进入自主编码推进阶段。
 
-> ⚡ **原生自主循环驱动机制 (Autonomous Driving Loop)**：
-> 无需记忆任何多余命令！进入 `03-work` 后，工作流扩展会自动在底层接管事件循环，按计划顺序逐个推进 Implementation Units。**每个单元完成后自动跨回合无缝驱动下一个单元，不做完所有规划单元绝不停机！**
+> ⚡ **连续自主推进机制 (Autonomous Continuous Loop)**：
+> 进入 `03-work` 后，必须按计划顺序逐个推进所有 Implementation Units。**严禁完成一个步骤就停下等待用户！每个单元完成后立即自主推进下一个单元，不做完所有规划单元绝不停机！**
 
 ---
 
 ## 🎯 启动与交互方式
 
 - **启动自主干活**：
-  直接运行 `/skill:03-work`（或在 00-next 引导下确认执行）。扩展自动定位 `docs/plans/` 下最新计划，解析所有 Implementation Units，并从上次断点处无缝接力。
+  直接运行 `/skill:03-work`（亦可在 00-next 引导下确认执行）。自动定位 `docs/plans/` 下最新计划，智能解析所有 Implementation Units（或步骤/任务），并从上次断点处接力推进。
 - **随时暂停**：
   干活过程中，若需打断，直接在输入框输入 `暂停`、`停止`（或按下终端 `Esc` 键），扩展将安全保存现场断点并挂起循环。
 - **恢复干活**：
-  随时再次调用 `/skill:03-work` 或发送 `继续`，即可从断点处再次恢复自主循环推进。
+  随时再次调用 `/skill:03-work`，即可从断点处再次恢复自主循环推进。
 - **查看状态**：
   随时运行 `/workflow`，即可查看当前 03-work 自主推进进度看板。
 
 ---
 
-## 🛡️ 核心工程纪律与硬门禁
+## 🛡️ 核心工程纪律与连续推进铁律
 
-1. **严格 TDD (红-绿-重构)**：
+1. **连续自主推进（严禁完成单步即停）**：
+   - 当任务目标或计划中包含多个步骤时，**绝对严禁每完成一步就停下向用户汇报或等待用户输入**！
+   - 每完成一个 Unit 并验证通过、保存断点后，**必须立即自主推进下一个待办 Unit**，连续执行直到计划中的所有 Implementation Units 全部完成并通过验证！
+   - 即使单次回合达到上下文或工具调用限制而结束，底层工作流扩展也会在 `agent_end` 自动注入续跑指令无缝接力下一单元。
+2. **严格 TDD (红-绿-重构)**：
    - 编写或补充对应当前 Unit 的测试用例（RED）。
    - 实现让测试通过的最简业务代码（GREEN）。
    - 运行该单元的确定性验收命令，确保 100% 绿灯。
-2. **断点自动同步 (Session Checkpoint)**：
+3. **断点自动同步 (Session Checkpoint & Markdown Checkboxes)**：
    - 每完成一个 Unit 并验证通过后，**必须立即调用**：
      `session_checkpoint({ operation: "save", planPath: "...", completedUnits: ["Unit X"] })`
-   - 底层引擎检测到断点更新后，会自动跨回合调度下一单元，模型绝不中途停下向用户求确认。
-3. **Stop-the-line (遇错即停硬门禁)**：
+     或在计划 Markdown 对应条目勾选 `[x]`。
+   - 记录断点后不要停顿，立即开始下一单元。
+4. **Stop-the-line (遇错即停硬门禁)**：
    - 当遇到非预期错误时，优先排查根因自愈。
    - **3次失败熔断阀门**：同一单元若连续 3 次排查修复仍失败，底层引擎强制启动 Stop-The-Line 保护，立即暂停自主循环并如实向用户报告现场，严禁盲目乱试或绕过未通过的测试。
-4. **全量闭环与自动转交**：
-   - 当所有 Implementation Units 均已通过验收命令时，自主循环自动宣告完成，并**自动流转至 `/skill:04-review` 进行全量代码审查与回归验证**。
+5. **全量闭环与自动转交**：
+   - 当所有 Implementation Units 均已通过验收命令时，自主循环宣告完成，并**自动流转至 `/skill:04-review` 进行全量代码审查与回归验证**。
 
 ---
 
@@ -55,6 +60,6 @@ description: "自主循环干活与严格 TDD 编码执行。按 Plan 中的 Imp
  │   [保存断点 SAVE] <── [验证通过 GREEN] <── [编写实现代码]
  │         │
  │         ▼
- └── (还有待办 Unit?) ──> 是: 引擎底层自动注入下一回合 (跨回合自主续跑)
+ └── (还有待办 Unit?) ──> 是: 立即自主执行下一个 Unit (连续推进，绝不停机等待)
                      └── 否: 全部完成！自动流转至 04-review 审查
 ```

package/extensions/workflow/skills/04-review/SKILL.md

@@ -7,6 +7,15 @@ description: "代码质量、Spec 规格与安全性审查。检查 Git 变更
 
 在编码实现完成（`03-work` 完成）后，使用本技能对所有变更进行严谨的质量把关与回归验证。
 
+## ⚠️ 核心审查原则：结合代码完整上下文（严禁仅看 diff 差异切片）
+
+1. **Diff 锁定改动范围**：首先通过 `git diff` 识别所有发生增删改的代码行与受影响的文件清单。
+2. **Read/Grep 深入上下文**：对每一个变动点，**绝对严禁仅凭局部 diff 片段断章取义**。必须使用 `read` / `grep` 查阅变动位置所在的完整函数实现、类定义、调用方前置守卫与全局数据流。
+3. **结合全貌精准判定**：
+   - 核实上游调用方是否已有前置校验与守卫拦截，避免误报“缺少安全防范”。
+   - 核实调用频次与数据规模，避免把仅执行一次的冷路径误判为“性能瓶颈”。
+   - 确认变更在全局执行流中确有逻辑缺陷或性能风险后，方可提出缺陷。
+
 ## 审查五大维度
 
 1. **Spec 规格一致性**：

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

@@ -7,17 +7,22 @@ export function isExplicit03WorkTrigger(prompt: string): boolean {
 	const trimmed = prompt.trim();
 	const lower = trimmed.toLowerCase();
 
-	// 1. Direct skill invocation or slash command
+	// 1. Pi 展开后的 Skill XML 标记: <skill name="03-work" ...>
+	if (lower.includes('<skill name="03-work"') || lower.startsWith('<skill name="03-work"')) {
+		return true;
+	}
+
+	// 2. 规范技能调用
 	if (lower.startsWith("/skill:03-work")) {
 		return true;
 	}
 
-	// 2. Strict keywords and natural language commands to start/resume 03 work
+	// 3. 严格意图的自然语言指令
 	const strictPatterns = [
-		/^开始(干活|编码|实现|写代码)/,
+		/^开始(?:干活|编码|实现|写代码)/,
 		/^执行03-work/,
-		/^自主(干活|工作|编码)/,
-		/^(继续|恢复)(干活|工作|work)/i,
+		/^自主(?:干活|工作|编码)/,
+		/^(?:继续|恢复)(?:干活|工作|work)/i,
 		/^resume\s+work/i,
 	];
 
@@ -25,7 +30,7 @@ export function isExplicit03WorkTrigger(prompt: string): boolean {
 		return true;
 	}
 
-	// 3. Autonomous continuation follow-up prompt generated by the driver itself
+	// 4. 自主循环驱动引擎内部生成的跨回合续跑提示词
 	if (trimmed.startsWith("【03-work 自主循环驱动引擎")) {
 		return true;
 	}

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

@@ -8,6 +8,50 @@ export interface PlanUnit {
 	id: string; // e.g. "Unit 0"
 	title: string; // e.g. "Unit 0 — 探针：面板焦点 / 键盘 / IME"
 	raw: string;
+	checked?: boolean;
+}
+
+/**
+ * 规范化单元标识符（如将 "Unit 0: DB Schema"、"unit 0"、"0" 等统一映射至标准 Unit ID）
+ */
+export function normalizeUnitId(rawId: string, knownUnits?: PlanUnit[]): string {
+	if (!rawId) return "";
+	const trimmed = rawId
+		.trim()
+		.replace(/^#+\s*/, "")
+		.replace(/^[-*+]\s*(?:\[[ xX]\]\s*)?/, "")
+		.replace(/^\d+\.\s*(?:\[[ xX]\]\s*)?/, "");
+
+	if (knownUnits && knownUnits.length > 0) {
+		const exact = knownUnits.find((u) => u.id.toLowerCase() === trimmed.toLowerCase());
+		if (exact) return exact.id;
+
+		const starts = knownUnits.find((u) => trimmed.toLowerCase().startsWith(u.id.toLowerCase()));
+		if (starts) return starts.id;
+
+		const numMatch = trimmed.match(/(\d+)/);
+		if (numMatch) {
+			const found = knownUnits.find((u) => {
+				const uNum = u.id.match(/(\d+)/);
+				return uNum && uNum[1] === numMatch[1];
+			});
+			if (found) return found.id;
+		}
+	}
+
+	const unitMatch = trimmed.match(/^(?:Implementation\s+Unit|Unit)\s*([0-9A-Za-z_-]+)/i);
+	if (unitMatch) return `Unit ${unitMatch[1]}`;
+
+	const zhMatch = trimmed.match(/^(?:步骤|单元|任务|阶段)\s*([0-9A-Za-z_-]+|[一二三四五六七八九十]+)/i);
+	if (zhMatch) return `步骤 ${zhMatch[1]}`;
+
+	const enMatch = trimmed.match(/^(?:Step|Task|Phase)\s*([0-9A-Za-z_-]+)/i);
+	if (enMatch) return `Unit ${enMatch[1]}`;
+
+	const numOnly = trimmed.match(/^([0-9]+)$/);
+	if (numOnly) return `Unit ${numOnly[1]}`;
+
+	return trimmed;
 }
 
 export interface WorkStatus {
@@ -34,11 +78,15 @@ export interface WorkStartResult {
 }
 
 /**
- * Parses Implementation Units from plan markdown.
- * Supports:
- * - `### Unit 0 — ...` or `### Unit 0: ...` or `## Unit 0`
+ * 从计划 Markdown 中解析执行单元 (Implementation Units / 步骤 / 任务)
+ * 支持格式：
+ * - `### Unit 0 — ...` / `### Unit 0: ...` / `## Unit 0`
  * - `### Implementation Unit 0: ...`
- * - `- [ ] Unit 0: ...`
+ * - `### 步骤 1: ...` / `### 步骤一: ...` / `### 单元 1: ...` / `### 任务 1: ...`
+ * - `### Step 1: ...` / `### Task 1: ...`
+ * - `- [ ] Unit 0: ...` / `- [x] Unit 0: ...`
+ * - `- [ ] 步骤 1: ...` / `- [x] 步骤 1: ...`
+ * - `- [ ] 1. xxx` / `- [x] 1. xxx`
  */
 export function parsePlanUnits(markdown: string): PlanUnit[] {
 	const units: PlanUnit[] = [];
@@ -48,30 +96,41 @@ export function parsePlanUnits(markdown: string): PlanUnit[] {
 	for (const line of lines) {
 		const trimmed = line.trim();
 
-		// Header match: ### Unit 0 — ... or ### Implementation Unit 1: ...
+		// 1. 标题匹配: ### Unit 0 — ... 或 ### 步骤 1: ... 或 ### 任务 1: ...
 		const headerMatch = trimmed.match(
-			/^#{2,4}\s+(?:Implementation\s+Unit|Unit)\s+([0-9A-Za-z_-]+)(?:\s*[:—–-]\s*(.*))?$/i,
+			/^#{2,4}\s+(?:Implementation\s+Unit|Unit|步骤|单元|任务|阶段|Step|Task|Phase)\s*([0-9A-Za-z_-]+|[一二三四五六七八九十]+)(?:\s*[:—–-]\s*(.*))?$/i,
 		);
 		if (headerMatch) {
-			const id = `Unit ${headerMatch[1]}`;
-			if (!seen.has(id.toLowerCase())) {
-				seen.add(id.toLowerCase());
+			const rawKey = headerMatch[1];
+			const isZh = /^(?:步骤|单元|任务|阶段)/.test(trimmed.replace(/^#{2,4}\s+/, ""));
+			const id = isZh ? `步骤 ${rawKey}` : `Unit ${rawKey}`;
+			const lowerId = id.toLowerCase();
+			if (!seen.has(lowerId)) {
+				seen.add(lowerId);
 				const title = headerMatch[2] ? `${id} — ${headerMatch[2].trim()}` : id;
-				units.push({ id, title, raw: trimmed });
+				const checked = /\[[xX]\]|~~/.test(trimmed);
+				units.push({ id, title, raw: trimmed, checked });
 				continue;
 			}
 		}
 
-		// List match: - [ ] Unit 0: ... or - [x] Unit 0
+		// 2. 复选框/列表匹配: - [ ] Unit 0: ... 或 - [x] 步骤 1: ... 或 - [x] 1. ...
 		const listMatch = trimmed.match(
-			/^-\s+\[[ xX]\]\s+(?:Implementation\s+Unit|Unit)\s+([0-9A-Za-z_-]+)(?:\s*[:—–-]\s*(.*))?$/i,
+			/^(?:-\s+|\d+\.\s+)\[([ xX])\]\s+(?:(?:Implementation\s+Unit|Unit|步骤|单元|任务|阶段|Step|Task|Phase)\s*)?([0-9A-Za-z_-]+|[一二三四五六七八九十]+)(?:[:.、—–-]\s*(.*))?$/i,
 		);
 		if (listMatch) {
-			const id = `Unit ${listMatch[1]}`;
-			if (!seen.has(id.toLowerCase())) {
-				seen.add(id.toLowerCase());
-				const title = listMatch[2] ? `${id} — ${listMatch[2].trim()}` : id;
-				units.push({ id, title, raw: trimmed });
+			const isChecked = listMatch[1].toLowerCase() === "x";
+			const rawKey = listMatch[2];
+			const isZh = /(?:步骤|单元|任务|阶段)/.test(trimmed);
+			const id = isZh ? `步骤 ${rawKey}` : `Unit ${rawKey}`;
+			const lowerId = id.toLowerCase();
+			if (!seen.has(lowerId)) {
+				seen.add(lowerId);
+				const title = listMatch[3] ? `${id} — ${listMatch[3].trim()}` : id;
+				units.push({ id, title, raw: trimmed, checked: isChecked });
+			} else if (isChecked) {
+				const existing = units.find((u) => u.id.toLowerCase() === lowerId);
+				if (existing) existing.checked = true;
 			}
 		}
 	}
@@ -116,6 +175,7 @@ export class WorkLoopDriver {
 	private maxRuns = 50; // Safety threshold against infinite runaway loops
 	private timer: NodeJS.Timeout | null = null;
 	private lastMessage = "";
+	private continuationDispatched = false;
 
 	constructor(repoRoot?: string) {
 		this.repoRoot = repoRoot || process.cwd();
@@ -149,6 +209,62 @@ export class WorkLoopDriver {
 		};
 	}
 
+	/**
+	 * 同步最新进度：同时读取 Markdown 计划文档中的已勾选复选框 (- [x]) 与 Session Checkpoint JSON
+	 */
+	async syncProgress(): Promise<void> {
+		if (!this.planPath) return;
+
+		// 1. 同步计划 Markdown 文档中的已勾选任务
+		try {
+			const mdContent = await readFile(this.planPath, "utf-8");
+			const freshUnits = parsePlanUnits(mdContent);
+			if (freshUnits.length > 0) {
+				this.allUnits = freshUnits;
+			}
+			for (const u of freshUnits) {
+				if (u.checked) {
+					this.completedUnits.add(u.id);
+				}
+			}
+		} catch {}
+
+		// 2. 同步 Checkpoint JSON 断点
+		try {
+			const cpResult = await executeSessionCheckpoint({
+				operation: "load",
+				repoRoot: this.repoRoot,
+				planPath: this.planPath,
+				planSlug: this.planSlug || undefined,
+			});
+
+			if (cpResult.checkpoint) {
+				const cp = cpResult.checkpoint;
+				if (cp.completedUnits) {
+					for (const raw of cp.completedUnits) {
+						const norm = normalizeUnitId(raw, this.allUnits);
+						this.completedUnits.add(norm);
+					}
+				}
+
+				if (cp.failedUnit) {
+					this.failedUnit = normalizeUnitId(cp.failedUnit, this.allUnits);
+					this.consecutiveFailures += 1;
+					this.lastFailureError = cp.error || "测试执行未通过";
+					this.failureHistory.push({
+						unit: cp.failedUnit,
+						error: cp.error,
+						timestamp: new Date().toISOString(),
+					});
+				} else {
+					this.consecutiveFailures = 0;
+					this.failedUnit = null;
+					this.lastFailureError = null;
+				}
+			}
+		} catch {}
+	}
+
 	/**
 	 * Starts autonomous work loop on a target plan.
 	 */
@@ -196,21 +312,10 @@ export class WorkLoopDriver {
 		this.failedUnit = null;
 		this.lastFailureError = null;
 		this.failureHistory = [];
-
-		// Load existing checkpoint
-		const cpResult = await executeSessionCheckpoint({
-			operation: "load",
-			repoRoot: this.repoRoot,
-			planPath: targetPlan,
-			planSlug: this.planSlug,
-		});
-
 		this.completedUnits.clear();
-		if (cpResult.checkpoint && cpResult.checkpoint.completedUnits) {
-			for (const u of cpResult.checkpoint.completedUnits) {
-				this.completedUnits.add(u);
-			}
-		}
+
+		// 同步断点与已勾选单元
+		await this.syncProgress();
 
 		const status = this.getStatus();
 		if (status.remainingUnits.length === 0) {
@@ -272,95 +377,88 @@ export class WorkLoopDriver {
 			`请严格执行以下闭环操作，完成后自动推进，严禁询问确认：`,
 			`1. 遵循 TDD (红-绿-重构)：编写/补充针对 ${status.currentUnit} 的测试用例。`,
 			`2. 编写最小化实现代码，执行该单元的确定性验证命令，确保全绿灯。`,
-			`3. 验证通过后，【必须立即调用】session_checkpoint({ operation: "save", planPath: "${this.planPath}", completedUnits: ["${status.currentUnit}"] }) 保存断点。`,
+			`3. 验证通过后，【必须立即调用】session_checkpoint({ operation: "save", planPath: "${this.planPath}", completedUnits: ["${status.currentUnit}"] }) 保存断点，或在计划文档对应项勾选 [x]。`,
 			`4. 若遇到非预期报错，排查根因。若重试仍失败，调用 session_checkpoint({ operation: "fail", planPath: "${this.planPath}", failedUnit: "${status.currentUnit}", error: "..." })。`,
 			`5. 执行完毕后若无致命异常，请直接准备推进下一单元。`,
 		].join("\n");
 	}
 
 	/**
-	 * Hooks into agent_settled to evaluate completion and trigger next turn if needed.
+	 * 在单轮/整段结束 (agent_end) 时主动评估，无缝跨回合排队注入下一单元 (Native Continuous Loop)
 	 */
-	async onAgentSettled(ctx: ExtensionContext, pi: ExtensionAPI): Promise<void> {
+	async onAgentEnd(
+		event: { messages: any[] },
+		ctx: ExtensionContext,
+		pi: ExtensionAPI,
+	): Promise<void> {
 		if (!this.isActive || !this.planPath) return;
 
-		// 1. Check if user aborted (Esc pressed, abort signal, or aborted assistant message)
-		if (ctx.signal?.aborted) {
-			await this.pause("检测到用户中断信号 (Esc/Abort)");
+		// 1. 检查中断信号
+		const hasAborted =
+			ctx.signal?.aborted ||
+			event.messages.some((m: any) => m?.role === "assistant" && m?.stopReason === "aborted");
+		if (hasAborted) {
+			await this.pause("检测到会话中断信号 (Ctrl+C / Esc)");
 			ctx.ui?.setStatus?.("workflow", undefined);
 			ctx.ui?.notify?.("⏸️ 03-work 自主循环已响应中断信号安全暂停。", "info");
 			return;
 		}
 
-		try {
-			const branch = ctx.sessionManager?.getBranch?.() ?? [];
-			const lastMsgEntry = branch
+		// 记录本轮开始前的当前目标
+		const currentTarget = this.getStatus().currentUnit;
+
+		// 2. 同步磁盘上的断点与 Markdown 勾选项
+		await this.syncProgress();
+
+		// 容错处理：若助手正常结束了本轮任务且未报告错误，但既未调用 session_checkpoint 也未修改 [x]
+		// 自动将当前单元标记为完成并同步断点，防止死锁停留在同一单元
+		if (currentTarget && !this.completedUnits.has(currentTarget)) {
+			const lastAssistant = event.messages
 				.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",
-			repoRoot: this.repoRoot,
-			planPath: this.planPath,
-			planSlug: this.planSlug || undefined,
-		});
-
-		if (cpResult.checkpoint) {
-			const cp = cpResult.checkpoint;
-			if (cp.completedUnits) {
-				for (const u of cp.completedUnits) {
-					this.completedUnits.add(u);
-				}
+				.find((m: any) => m?.role === "assistant");
+
+			const isAbortOrError =
+				lastAssistant?.stopReason === "aborted" ||
+				lastAssistant?.stopReason === "error" ||
+				Boolean(this.failedUnit);
+
+			if (!isAbortOrError) {
+				this.completedUnits.add(currentTarget);
+				// 异步回写 Checkpoint 保存断点，保证断点不丢
+				executeSessionCheckpoint({
+					operation: "save",
+					repoRoot: this.repoRoot,
+					planPath: this.planPath,
+					planSlug: this.planSlug || undefined,
+					completedUnits: Array.from(this.completedUnits),
+				}).catch(() => {});
 			}
+		}
 
-			// Check Stop-The-Line failure gate
-			if (cp.failedUnit) {
-				this.failedUnit = cp.failedUnit;
-				this.consecutiveFailures += 1;
-				this.lastFailureError = cp.error || "未知测试失败";
-				this.failureHistory.push({
-					unit: cp.failedUnit,
-					error: cp.error,
-					timestamp: new Date().toISOString(),
-				});
-				if (this.consecutiveFailures >= 3) {
-					await this.pause(
-						`硬门禁触发：${cp.failedUnit} 连续排查修复未果 (${this.lastFailureError})，触发 Stop-The-Line 遇错即停保护。`,
-					);
-					ctx.ui?.notify?.(
-						`🛑 03-work 遇到连续失败，已启动遇错即停硬门禁保护，请排查原因。`,
-						"error",
-					);
-					return;
-				}
-			} else {
-				this.consecutiveFailures = 0;
-				this.failedUnit = null;
-				this.lastFailureError = null;
-			}
+		// 检查遇错即停门禁
+		if (this.consecutiveFailures >= 3) {
+			await this.pause(
+				`硬门禁触发：${this.failedUnit || "当前单元"} 连续排查修复未果 (${this.lastFailureError})，触发 Stop-The-Line 遇错即停保护。`,
+			);
+			ctx.ui?.notify?.(
+				`🛑 03-work 遇到连续失败，已启动遇错即停硬门禁保护，请排查原因。`,
+				"error",
+			);
+			return;
 		}
 
-		// 3. Check if all units are finished
+		// 3. 检查是否全部单元均已达成
 		const status = this.getStatus();
 		if (status.remainingUnits.length === 0) {
 			this.isActive = false;
+			this.cancelTimer();
 			ctx.ui?.setStatus?.("workflow", undefined);
 			ctx.ui?.notify?.(
 				`🎉 03-work 全部 ${this.allUnits.length} 个规划单元已全部实现并验证通过！自动流转至 04-review 审查阶段。`,
 				"info",
 			);
 
-			// Automatically transition to 04-review
 			try {
 				pi.sendUserMessage(
 					"【03-work 全部单元已圆满完成】所有 Implementation Units 测试与验收命令均已绿灯通过。现在自动启动 /skill:04-review 进行最终质量审查与回归核验。",
@@ -372,7 +470,7 @@ export class WorkLoopDriver {
 			return;
 		}
 
-		// 4. Safety runaway cap
+		// 4. 防失控超轮次保护
 		this.currentRunCount += 1;
 		if (this.currentRunCount > this.maxRuns) {
 			await this.pause(`自主续跑轮次已达安全上限 (${this.maxRuns} 轮)，避免无限死循环。`);
@@ -383,37 +481,137 @@ export class WorkLoopDriver {
 			return;
 		}
 
-		// 5. Update footer status
+		// 5. 更新底部状态栏
 		const percent = Math.round((status.completedUnits.length / status.allUnits.length) * 100);
 		ctx.ui?.setStatus?.(
 			"workflow",
 			`🔄 03-work 自主干活 [${status.completedUnits.length}/${status.allUnits.length} - ${percent}%] 下一个: ${status.currentUnit}`,
 		);
 
-		// 6. Schedule next autonomous turn
+		// 6. 派发下一单元指令
 		const nextPrompt = this.generatePromptForNextUnit();
 		if (!nextPrompt) return;
 
 		this.cancelTimer();
-		// Give a brief 100ms pause so Pi's event loop settles cleanly, then dispatch follow-up
-		this.timer = setTimeout(() => {
-			try {
-				this.timer = null;
+		// 在 agent_end 中调用 sendUserMessage({ deliverAs: "followUp" })，
+		// Pi 底层将把消息放入队列并在 _handlePostAgentRun 中直接循环 continue()，无缝自主续跑！
+		try {
+			pi.sendUserMessage(nextPrompt, {
+				deliverAs: "followUp",
+				expandPromptTemplates: true,
+			});
+			this.continuationDispatched = true;
+		} catch {
+			this.continuationDispatched = false;
+			// 若环境不支持在 agent_end 立即派发，使用延时兜底
+			this.timer = setTimeout(() => {
 				if (!this.isActive) return;
-
 				pi.sendUserMessage(nextPrompt, {
 					deliverAs: "followUp",
 					expandPromptTemplates: true,
 				});
-			} catch (err) {
-				console.error("[03-work driver] setTimeout callback failed:", err);
-				this.isActive = false;
-				this.cancelTimer();
+			}, 100);
+			this.timer.unref?.();
+		}
+	}
+
+	/**
+	 * 在 agent_settled 时提供兜底保障，确保如果 agent_end 未能成功排队时继续调度
+	 */
+	async onAgentSettled(ctx: ExtensionContext, pi: ExtensionAPI): Promise<void> {
+		if (!this.isActive || !this.planPath) return;
+
+		// 1. 检查中断信号 (Esc / ctx.signal / 会话内最后一条 assistant aborted)
+		if (ctx.signal?.aborted) {
+			await this.pause("检测到用户中断信号 (Esc/Abort)");
+			ctx.ui?.setStatus?.("workflow", undefined);
+			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 自主循环遇到内部错误已暂停，请查看日志。", "warning");
-				this.lastMessage = `续跑调度异常: ${err instanceof Error ? err.message : String(err)}`;
+				ctx.ui?.notify?.("⏸️ 03-work 自主循环已响应中断信号安全暂停。", "info");
+				return;
 			}
-		}, 100);
-		this.timer.unref?.();
+		} catch {}
+
+		// 2. 同步进度
+		await this.syncProgress();
+
+		// 3. 检查遇错即停门禁
+		if (this.consecutiveFailures >= 3) {
+			await this.pause(
+				`硬门禁触发：${this.failedUnit || "当前单元"} 连续排查修复未果 (${this.lastFailureError})，触发 Stop-The-Line 遇错即停保护。`,
+			);
+			ctx.ui?.notify?.(
+				`🛑 03-work 遇到连续失败，已启动遇错即停硬门禁保护，请排查原因。`,
+				"error",
+			);
+			return;
+		}
+
+		// 4. 检查是否全部单元完成
+		const status = this.getStatus();
+		if (status.remainingUnits.length === 0) {
+			this.isActive = false;
+			this.cancelTimer();
+			ctx.ui?.setStatus?.("workflow", undefined);
+			ctx.ui?.notify?.(
+				`🎉 03-work 全部 ${this.allUnits.length} 个规划单元已全部实现并验证通过！自动流转至 04-review 审查阶段。`,
+				"info",
+			);
+
+			try {
+				pi.sendUserMessage(
+					"【03-work 全部单元已圆满完成】所有 Implementation Units 测试与验收命令均已绿灯通过。现在自动启动 /skill:04-review 进行最终质量审查与回归核验。",
+					{ deliverAs: "followUp", expandPromptTemplates: true },
+				);
+			} catch {}
+			return;
+		}
+
+		// 5. 超轮次保护
+		this.currentRunCount += 1;
+		if (this.currentRunCount > this.maxRuns) {
+			await this.pause(`自主续跑轮次已达安全上限 (${this.maxRuns} 轮)，避免无限死循环。`);
+			ctx.ui?.setStatus?.("workflow", undefined);
+			ctx.ui?.notify?.("⚠️ 03-work 自主续跑已达安全轮次上限已暂停。", "warning");
+			return;
+		}
+
+		// 如果在 agent_end 中已经成功派发了 continuation，则无需在 settled 中重复发送
+		if (this.continuationDispatched) {
+			this.continuationDispatched = false;
+			return;
+		}
+
+		// 6. 如果当前仍处于活跃状态且计时器未启动，补发一次续跑调度 (兜底)
+		if (this.isActive && !this.timer) {
+			const nextPrompt = this.generatePromptForNextUnit();
+			if (!nextPrompt) return;
+
+			this.timer = setTimeout(() => {
+				try {
+					this.timer = null;
+					if (!this.isActive) return;
+
+					pi.sendUserMessage(nextPrompt, {
+						deliverAs: "followUp",
+						expandPromptTemplates: true,
+					});
+				} catch (err) {
+					console.error("[03-work driver] onAgentSettled fallback failed:", err);
+				}
+			}, 100);
+			this.timer.unref?.();
+		}
 	}
 }

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

@@ -70,7 +70,12 @@ const { default: workflowExtension } = await import(
 	pathToFileURL(path.join(tempBuildDir, "index.js"))
 );
 
-const { parsePlanUnits, WorkLoopDriver, isExplicit03WorkTrigger } = await import(
+const {
+	parsePlanUnits,
+	WorkLoopDriver,
+	isExplicit03WorkTrigger,
+	normalizeUnitId,
+} = await import(
 	pathToFileURL(path.join(tempBuildDir, "src/driver/work-loop-driver.js"))
 );
 
@@ -324,8 +329,25 @@ Done.
 	assert.equal(units[0].title, "Unit 0 — 探针：面板焦点 / 键盘 / IME (阻塞所有 UI 工作)");
 	assert.equal(units[1].id, "Unit 1");
 	assert.equal(units[2].id, "Unit 2");
+	assert.equal(units[2].checked, false);
 	assert.equal(units[3].id, "Unit 3");
+	assert.equal(units[3].checked, true);
 	assert.equal(units[4].id, "Unit 4");
+
+	// Test Chinese step headers and list items
+	const chinesePlanMd = `
+# 中文任务规划
+### 步骤 1: 基础设施配置
+- [x] 步骤 2: 核心协议实现
+- [ ] 步骤 3: 全量单元测试与回归
+`;
+	const zhUnits = parsePlanUnits(chinesePlanMd);
+	assert.equal(zhUnits.length, 3);
+	assert.equal(zhUnits[0].id, "步骤 1");
+	assert.equal(zhUnits[1].id, "步骤 2");
+	assert.equal(zhUnits[1].checked, true);
+	assert.equal(zhUnits[2].id, "步骤 3");
+	assert.equal(zhUnits[2].checked, false);
 });
 
 test("WorkLoopDriver: autonomous lifecycle and prompt generation", async () => {
@@ -470,21 +492,27 @@ 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
+test("isExplicit03WorkTrigger: accurately identifies canonical 03-work invocations vs harmless inputs", async () => {
+	// Should match canonical /skill:03-work, Pi's expanded XML, strict natural language, and engine follow-up
 	assert.equal(isExplicit03WorkTrigger("/skill:03-work"), true);
+	assert.equal(isExplicit03WorkTrigger('<skill name="03-work" location="extensions/workflow/skills/03-work/SKILL.md">'), true);
 	assert.equal(isExplicit03WorkTrigger("开始干活"), true);
 	assert.equal(isExplicit03WorkTrigger("开始实现"), true);
+	assert.equal(isExplicit03WorkTrigger("开始编码"), true);
+	assert.equal(isExplicit03WorkTrigger("开始写代码"), true);
 	assert.equal(isExplicit03WorkTrigger("执行03-work"), true);
 	assert.equal(isExplicit03WorkTrigger("继续干活"), true);
 	assert.equal(isExplicit03WorkTrigger("恢复干活"), true);
 	assert.equal(isExplicit03WorkTrigger("resume work"), true);
 	assert.equal(isExplicit03WorkTrigger("【03-work 自主循环驱动引擎 · 自动化续跑指令】"), true);
 
-	// Alias /skill:03 or plain numbers must NEVER trigger (strictly require full skill name /skill:03-work)
+	// Plain numbers or informal abbreviations must NEVER trigger (strictly require canonical name)
 	assert.equal(isExplicit03WorkTrigger("/skill:03"), false);
 	assert.equal(isExplicit03WorkTrigger("03"), false);
 	assert.equal(isExplicit03WorkTrigger("/03"), false);
+	assert.equal(isExplicit03WorkTrigger("03-work"), false);
+	assert.equal(isExplicit03WorkTrigger("/03-work"), false);
+	assert.equal(isExplicit03WorkTrigger("/work"), false);
 
 	// Must NEVER match other skills or normal dialogue (prevents false auto-starts!)
 	assert.equal(isExplicit03WorkTrigger("00"), false);
@@ -504,6 +532,21 @@ test("isExplicit03WorkTrigger: accurately identifies 03-work invocations vs harm
 	assert.equal(isExplicit03WorkTrigger("   "), false);
 });
 
+test("normalizeUnitId: correctly normalizes unit representations to standard IDs", async () => {
+	const knownUnits = [
+		{ id: "Unit 0", title: "Unit 0: DB Schema", raw: "### Unit 0: DB Schema" },
+		{ id: "Unit 1", title: "Unit 1: API Endpoint", raw: "### Unit 1: API Endpoint" },
+	];
+
+	assert.equal(normalizeUnitId("Unit 0: DB Schema", knownUnits), "Unit 0");
+	assert.equal(normalizeUnitId("unit 0", knownUnits), "Unit 0");
+	assert.equal(normalizeUnitId("0", knownUnits), "Unit 0");
+	assert.equal(normalizeUnitId("1", knownUnits), "Unit 1");
+	assert.equal(normalizeUnitId("### Unit 0 — Alpha"), "Unit 0");
+	assert.equal(normalizeUnitId("步骤 2: 业务逻辑"), "步骤 2");
+	assert.equal(normalizeUnitId(""), "");
+});
+
 test("workflow-dashboard: derives all 5 steps and renders goal-style status dashboard", async () => {
 	const mockState = {
 		repoRoot: "/test/repo",

package/package.json

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