@ghyper9023/pi-dev-workflow 0.6.0 → 0.6.2

package/README.md

@@ -14,7 +14,8 @@ pi install git:github.com/cherish-ltt/pi-dev-workflow
 
 然后 `/reload` 热加载即可使用所有功能。
 > [!NOTE]  
-> 本pi-package存在sub-agent功能，会与其他使用sub-agent功能的pi-package冲突，但冲突可以修复，请提交issue或自行处理。
+> - 本pi-package存在sub-agent功能，会与其他使用sub-agent功能的pi-package冲突，但冲突可以修复，请提交issue或自行处理。
+> - 本pi-package添加了`APPEND_SYSTEM.md`，存在默认使用中文等特色设定，需要自行修改`prompts/APPEND_SYSTEM.md`。
 
 ## 目录结构
 
@@ -54,6 +55,7 @@ pi-package/
 │   └── to-prd/
 │       └── SKILL.md                 # 从对话上下文生成 PRD 文档
 ├── extensions/
+│   ├── append-system.ts             # 追加APPEND_SYSTEM.md提示词
 │   ├── dev-prompts.ts               # 提示词优化向导（/dev-* 命令）
 │   ├── git-commands.ts              # git-sub-agent 命令
 │   ├── grill-me-agent.ts            # Grill + PRD 运行时：方案追问完善、PRD 生成

package/agents/workflow/planner-agent.md

@@ -51,7 +51,7 @@ extra-args:
 
 请严格按照以下 Markdown 格式生成计划文件：
 
-```markdown
+````markdown
 # {功能名称} — 实施计划
 
 ## 概述
@@ -128,4 +128,4 @@ extra-args:
 ## ⚠️ 关键注意事项与风险防御
 * **潜在风险点**：注意 `discountPrice` 为空时的默认回退机制，避免在生产环境引发 `NaN` 错误。
 * **手动确认**：需确保上游网关已放行新字段，否则本地集成测试通过后线上也可能获取不到数据。
-```
+````

package/agents/workflow/reviewer-agent.md

@@ -54,7 +54,7 @@ extra-args:
 
 写入 `.pi-dev-output/pi-review/md/` 的文件必须采用以下格式：
 
-```markdown
+````markdown
 # 🔍 代码审查报告 — {功能/任务名称}
 
 ## 📊 审计摘要
@@ -64,7 +64,7 @@ extra-args:
 
 | 🔴 严重 (Critical) | 🟡 中等 (Medium) | 🟢 低优先级 (Low) |
 | :---: | :---: | :---: |
-| 0 | 2 | 3 |
+| 1 | 2 | 3 |
 
 ---
 
@@ -85,7 +85,16 @@ extra-args:
   ```
 ### [🟡 中等] 示例：`src/components/List.tsx` 重复渲染隐患
 ...
+
+### [🟢 低优先级] 示例：`src/application/mod.rs` 未格式化
+...
+
+```json
+[REVIEW_SUMMARY]
+{"maxSeverity":"critical","critical":1,"medium":2,"low":3}
+[/REVIEW_SUMMARY]
 ```
+````
 
 ---
 

package/extensions/append-system.ts

@@ -0,0 +1,36 @@
+/**
+ * APPEND_SYSTEM.md 注入扩展
+ *
+ * 在每次 agent 启动前，将 prompts/APPEND_SYSTEM.md 的内容追加到 system prompt 末尾。
+ * 这样用户安装此包后，自动生效，无需手动配置 ~/.pi/agent/APPEND_SYSTEM.md。
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+	// 缓存文件内容，避免每次读取磁盘
+	let cachedContent: string | null = null;
+
+	function getAppendContent(): string {
+		if (cachedContent !== null) return cachedContent;
+		try {
+			const appendPath = join(__dirname, "..", "prompts", "APPEND_SYSTEM.md");
+			cachedContent = readFileSync(appendPath, "utf-8");
+		} catch {
+			// 文件不存在时静默降级，不阻塞启动
+			cachedContent = "";
+		}
+		return cachedContent;
+	}
+
+	pi.on("before_agent_start", async (event, _ctx) => {
+		const content = getAppendContent();
+		if (!content) return; // 无可追加内容
+
+		return {
+			systemPrompt: (event.systemPrompt || "") + "\n\n" + content,
+		};
+	});
+}

package/extensions/workflow-engine.ts

@@ -389,20 +389,16 @@ function getGitDiffChanges(cwd: string): GitFileChange[] {
 }
 
 /**
- * Convert an internal tool type ("edit"/"new"/"delete") to a git status letter ("M"/"A"/"D").
- * Used to unify all tool entries to git-format display: "M   path", "A   path", "D   path".
+ * 检查路径是否为工作流生成的产物路径（.pi-dev-output/），
+ * 若是则不应出现在 A: M: D: 文件变更列表中。
+ * 该目录已加入 .gitignore，git diff 本身已忽略，
+ * 此函数作为防御性过滤。
  */
-function toGitStatus(toolType: string): string {
-	switch (toolType.toLowerCase()) {
-		case "new": case "write": case "create": case "add": case "created": case "added":
-			return "A";
-		case "delete": case "remove": case "deleted": case "removed":
-			return "D";
-		default:
-			return "M";
-	}
+function isWorkflowArtifactPath(filePath: string): boolean {
+	return filePath.startsWith(".pi-dev-output/");
 }
 
+
 /**
  * Check whether a file's current content hash differs from its baseline.
  * Returns true if the hash changed or the file is no longer accessible.
@@ -453,6 +449,7 @@ function captureBaseline(cwd: string): void {
  * loop-group, then reviewed by reviewer) without being collapsed into one.
  * Without :stepIndex, the Set dedup would wrongly skip a file modified in
  * a later step just because it was already tracked in an earlier step.
+ *
  */
 function updateToolsFromGit(cwd: string, stepIndex: number, agentName: string): void {
 	const currentChanges = getGitDiffChanges(cwd);
@@ -480,7 +477,7 @@ function updateToolsFromGit(cwd: string, stepIndex: number, agentName: string):
 		// and should NOT be reported as user repo changes. Real git clients (VSCode, Zed) also
 		// ignore this directory (it's in .gitignore). This filter is defense-in-depth.
 		// Note: git always uses forward slashes in paths, even on Windows.
-		if (change.path.startsWith(".pi-dev-output/")) continue;
+		if (isWorkflowArtifactPath(change.path)) continue;
 
 		seen.add(`${change.path}:${stepIndex}`);
 		const type: FileChangeEntry["type"] =
@@ -1094,35 +1091,81 @@ async function runAgentWithProgress(
 		}
 	}
 
-	// Parse progress messages for tool calls and outputs
-	// NOTE: In-progress parsing is best-effort and intentionally conservative.
-	// Final file change detection relies on git diff --name-status (see updateToolsFromGit below)
-	// which is 100% accurate and free of AI text noise.
-	const result = await spawnSubagent(agent, task, _workflowCwd, signal, timeoutMs, (progress) => {
-		// Try to parse tool calls from progress messages
-		// Only match if it looks like a file path (contains a dot or path separator)
-		const toolMatch = progress.match(/(edit|read|write|new|bash|grep|find|ls|delete|remove)\s*[:：]\s*([\w./\\-]+)/i);
-		if (toolMatch) {
-			const toolType = toolMatch[1]!.toLowerCase();
-			const target = toolMatch[2]!;
-			// Only classify as file operation if it's a file path-like string
-			if (target.includes(".") || target.includes("/") || target.includes("\\")) {
-				const gitStatus = toGitStatus(toolType);
-				addWidgetSubStepTool(stepIndex, agentName, `${gitStatus}   ${target}`);
-				_widgetExtraToolCount++;
-			}
-		}
-		// Detect output file paths — only match .pi-dev-output paths belonging to current workflow
-		if (_workflowId) {
-			const outputMatch = progress.match(/\.pi-dev-output\/[^\s,;)\]}'"`]{5,}\.\w+/i);
-			if (outputMatch) {
-				const pathCandidate = outputMatch[0]!.trim().replace(/["'`\\]+$/g, '');
-				if (pathCandidate.length > 15 && pathCandidate.length < 300 && pathCandidate.includes(_workflowId)) {
-					addWidgetSubStepOutput(stepIndex, agentName, pathCandidate);
+	// ── Start git diff polling for real file changes ──
+	// This replaces the unreliable regex-based tool call sniffing that was removed.
+	// git diff --name-status is the same approach used by VSCode, Zed, and every
+	// professional git client — it's deterministic, noise-free, and 100% accurate.
+	let _gitPollTimer: ReturnType<typeof setInterval> | null = null;
+	const _pollSeen = new Set<string>();
+	if (_workflowCwd) {
+		_gitPollTimer = setInterval(() => {
+			try {
+				const currentChanges = getGitDiffChanges(_workflowCwd);
+				for (const change of currentChanges) {
+					const key = `${change.path}:${stepIndex}`;
+					if (_pollSeen.has(key)) continue;
+					_pollSeen.add(key);
+
+					if (isWorkflowArtifactPath(change.path)) continue;
+					if (_workflowBaseline.length > 0) {
+						const baseEntry = _workflowBaseline.find(b => b.path === change.path);
+						if (baseEntry) {
+							if (!hasContentChanged(_workflowCwd, change.path, baseEntry.hash)) continue;
+							// ⭐ 同步删除已变更的基线条目，与 updateToolsFromGit 行为一致
+							_workflowBaseline = _workflowBaseline.filter(b => b.path !== change.path);
+						}
+					}
+
+					// ⭐ Also record in _workflowFileChanges so the completion report file tree
+					// and revertStepChanges have accurate data. The final updateToolsFromGit call
+					// will skip this via seen, so we must record it here.
+					const type: FileChangeEntry["type"] =
+						change.status === "A" ? "new" :
+						change.status === "D" ? "delete" :
+						"edit";
+					_workflowFileChanges.push({
+						agent: agentName,
+						stepIndex,
+						type,
+						filePath: change.path,
+						timestamp: new Date().toISOString(),
+					});
+					addWidgetSubStepTool(stepIndex, agentName, `${change.status}   ${change.path}`);
+					_widgetExtraToolCount++;
+				}
+			} catch { /* 静默忽略 git 错误 */ }
+		}, 5000);
+		_gitPollTimer.unref();
+	}
+
+	// Run the sub-agent with progress reporting
+	// The toolMatch regex sniffing has been removed — it was the primary source of
+	// false positives in the A: M: D: panel (matching AI natural language as tool calls).
+	// File change detection is now handled entirely by git diff polling (above) and
+	// the final updateToolsFromGit call (below), both of which use git's own API.
+	let result;
+	try {
+		result = await spawnSubagent(agent, task, _workflowCwd, signal, timeoutMs, (progress) => {
+			// Detect output file paths — only match .pi-dev-output paths belonging to current workflow
+			if (_workflowId) {
+				const outputMatch = progress.match(/\.pi-dev-output\/[a-zA-Z0-9_\/\.-]+/i);
+				if (outputMatch) {
+					const pathCandidate = outputMatch[0]!.trim();
+					// ⭐ 严格白名单：拒绝中文、引号、括号等非路径字符
+					if (pathCandidate.length > 15 && pathCandidate.length < 300 &&
+						pathCandidate.includes(_workflowId) &&
+						/^[\w.\/-]+$/.test(pathCandidate)) {
+						addWidgetSubStepOutput(stepIndex, agentName, pathCandidate);
+					}
 				}
 			}
+		}, _workflowId ? { workflowId: _workflowId } : undefined);
+	} finally {
+		if (_gitPollTimer) {
+			clearInterval(_gitPollTimer);
+			_gitPollTimer = null;
 		}
-	}, _workflowId ? { workflowId: _workflowId } : undefined);
+	}
 
 	const agentDuration = Date.now() - agentStartTime;
 
@@ -1142,23 +1185,30 @@ async function runAgentWithProgress(
 	// from code snippets). Instead, we rely entirely on git diff --name-status, which is
 	// the same approach used by VSCode, Zed, and every other professional git client.
 	// It's deterministic, noise-free, and always produces correct relative paths.
-	const allOutput = (result.output || "") + "\n" + (result.stderr || "");
 	const finalOutput = extractFinalOutput(result.output) || result.output;
-	const searchText = allOutput + "\n" + finalOutput;
 
 	// Find output file paths (plans, reviews) for display in the "output:" section
 	// These are workflow artifacts (.pi-dev-output/) — only show files belonging to
 	// the CURRENT workflow to avoid cross-contamination from previous runs.
 	// Note: file change detection itself relies exclusively on git diff below, not text parsing.
+	// ⭐ IMPORTANT: Only search in CLEAN extracted text (finalOutput), NOT raw JSON output.
+	//   The old approach concatenated allOutput (raw JSON + stderr) into searchText and
+	//   matched against it, producing false positives from JSON stringified content.
+	//   By restricting to extractFinalOutput's clean text, we avoid matching against
+	//   JSON-escaped paths, code snippets, or natural language in raw agent output.
+	const cleanText = finalOutput || result.output || "";
 	const seenOutputs = new Set<string>();
 	if (_workflowId) {
 		// Only match .pi-dev-output paths containing the current workflow UUID
 		const escapedId = _workflowId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-		const outputPattern = new RegExp(`\\.pi-dev-output\\/[^\\s,;)\\]}'"\\`]*${escapedId}[^\\s,;)\\]}'"\\`]*`, 'g');
+		const outputPattern = new RegExp(`\\.pi-dev-output\\/[a-zA-Z0-9_\\/.-]*${escapedId}[a-zA-Z0-9_\\/.-]*`, 'g');
 		let m;
-		while ((m = outputPattern.exec(searchText)) !== null) {
+		while ((m = outputPattern.exec(cleanText)) !== null) {
 			const path_ = m[0]!.trim();
 			if (path_.length > 15 && path_.length < 300 && !seenOutputs.has(path_)) {
+				// ⭐ 严格白名单：仅允许 [a-zA-Z0-9_./-] 字符
+				// 拒绝包含中文、引号、括号、空格等非路径字符的乱码匹配
+				if (!/^[\w.\/-]+$/.test(path_)) continue;
 				seenOutputs.add(path_);
 				addWidgetSubStepOutput(stepIndex, agentName, path_);
 			}
@@ -1167,9 +1217,11 @@ async function runAgentWithProgress(
 		// No workflow ID (unlikely): match .pi-dev-output paths conservatively
 		const outputPattern = /\.pi-dev-output\/[a-zA-Z0-9_\/-]+\.[a-zA-Z0-9]+/g;
 		let m;
-		while ((m = outputPattern.exec(searchText)) !== null) {
+		while ((m = outputPattern.exec(cleanText)) !== null) {
 			const path_ = m[0]!.trim();
 			if (path_.length > 15 && path_.length < 300 && !seenOutputs.has(path_)) {
+				// ⭐ 严格白名单
+				if (!/^[\w.\/-]+$/.test(path_)) continue;
 				seenOutputs.add(path_);
 				addWidgetSubStepOutput(stepIndex, agentName, path_);
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghyper9023/pi-dev-workflow",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "keywords": [
     "pi-package"
   ],

package/prompts/APPEND_SYSTEM.md

@@ -1,12 +1,59 @@
-## 必须严格遵守 - 全局适用
+# 必须严格遵守 - 全局适用
 
-### 语言
+## 一、职责定义
 
-- 使用**简体中文+英文专业名词**
+- **技术准确优先于迎合用户信念**。专注事实和解决问题，提供直接、客观的技术信息，避免不必要的夸张、赞美或情感认同。
+- 避免过度认同（如“你说得完全对”）。
+- **绝不给出时间预估**（不说“几分钟”“大约5分钟”“2-3周，我们以后在做”等）。
+- **默认不使用 emoji**，除非用户明确要求。
+- 输出在命令行显示，回答应**简短精炼**。
 
-### task完成
+## 二、核心行为约束
 
-- 在完成task后不主动commit或push，但可以提醒用户：
+### 1. 不要多管闲事
+- 不添加未要求的功能、不重构、不做“改进”。修复一个 bug 不需要清理周边代码。
+
+### 2. 不要过度设计
+- 不为不可能发生的场景添加错误处理、回退或校验。信任内部代码和框架保证。只在系统边界（用户输入、外部API）校验。
+
+### 3. 不要提前抽象
+- 不为一次性操作创建 helper、utility 或抽象层。不为假想的未来需求设计。**三行重复代码也好过一个过早出现的抽象**。
+
+### 4. 不要乱建文件
+- 除非绝对必要，**不创建新文件**。始终优先修改现有文件。
+- **绝不主动创建文档文件（\*.md）或 README**。
+
+### 5. 不改没读过的代码
+- 绝不提议修改没读过的代码。必须先阅读和理解再修改。
+
+### 6. 默认不写注释
+- 只在“为什么这样做”不显然时写注释（隐藏约束、微妙不变量、特定 bug 规避）。
+- 不解释代码“做了什么”——用良好命名的标识符表达。
+- 不在注释里引用当前任务、修复内容或调用方。
+- 不删除现有注释，除非删除其描述的代码。
+
+### 7. 如实汇报，不粉饰
+- 测试失败就说失败，带上相关输出。
+- 若未运行验证步骤，明确说明，不暗示成功。
+- 输出显示失败时，绝不声称“所有测试通过”。
+- 不压制或简化失败检查来制造表面绿色。
+- 不把未完成或损坏的工作说成已完成。
+
+## 三、动态语言配置
+
+- **始终使用用户(user-prompt)的语言回复**。所有解释、注释、与用户的交流都使用该语言。
+- 技术术语和代码标识符保持原样。
+- 未能清楚了解到用户(user-prompt)的语言时，默认使用简体中文+英文专业名词
+
+## 四、task完成
+
+- 默认情况下，使用简洁的语言总结任务
+- 如果用户有具体的要求，在任务完后按用户要求输出内容
+- 在完成task后绝不主动commit或push，但可以在任务总结末尾提醒用户(非处于子代理时)：
     1. review刚才的改动(输入/skill:review-html或1)
     2. 提交commit，自动message(输入/git-commit或2)
-    3. 提交commit，自动message，并push(输入/git-commit-push或3)
+    3. 提交commit，自动message，并push(输入/git-commit-push或3)
+
+## 五、核心理念
+
+> **高效达成请求结果，不过度工程。无范围蔓延。只实现直接要求的内容。无假想设计，无必要抽象，默认无注释。不为不可能条件加校验。无时间预估。无 emoji。无过度认同。准确、客观、简洁。始终牢记自己的身份和职责。**

package/tests/test-workflow-engine-bugs.mjs

@@ -502,12 +502,13 @@ assertTrue(hasWorkSummaryKey, "executeSingleStep 中保留 '工作总结' 条目
 const hasWorkSummaryUpdate = fullSingleStep.includes('updateChainContext');
 assertTrue(hasWorkSummaryUpdate, "executeSingleStep 中仍有 updateChainContext 调用（工作总结）");
 
-// Verify the removed summary keys are no longer present
-const hasPlannerKeyRemoved = !fullSingleStep.includes('"计划制定摘要"');
-assertTrue(hasPlannerKeyRemoved, "executeSingleStep 中已移除 '计划制定摘要' key");
-
-const hasDocWriterKeyRemoved = !fullSingleStep.includes('"文档更新摘要"');
-assertTrue(hasDocWriterKeyRemoved, "executeSingleStep 中已移除 '文档更新摘要' key");
+// Verify the removed summary keys are no longer present in updateChainContext calls
+// (comments may still reference them for historical context — that's fine)
+const chainCtxCalls = [...fullSingleStep.matchAll(/updateChainContext\(`([^`]+)`/g)].map(m => m[1]);
+const plannerInCode = chainCtxCalls.some(k => k.includes('计划制定摘要'));
+assertFalse(plannerInCode, "updateChainContext 中已不使用 '计划制定摘要' key");
+const docWriterInCode = chainCtxCalls.some(k => k.includes('文档更新摘要'));
+assertFalse(docWriterInCode, "updateChainContext 中已不使用 '文档更新摘要' key");
 
 
 console.log("\n═══ Bug H 测试 — Agent 前置元数据解析 ═══\n");
@@ -654,20 +655,25 @@ console.log("\n");
 
 console.log("═══ Bug J 测试 — _workflowFileChanges 仅来自 git diff ═══\n");
 
-// ── Test J1: _workflowFileChanges.push 仅出现在 updateToolsFromGit ──
-console.log("📋 测试 J1: _workflowFileChanges.push 仅出现在 updateToolsFromGit\n");
+// ── Test J1: _workflowFileChanges.push 出现在 updateToolsFromGit 和 git diff 轮询 ──
+console.log("📋 测试 J1: _workflowFileChanges.push 出现在 updateToolsFromGit 和 git diff 轮询\n");
 
 // Count all _workflowFileChanges.push occurrences
+// There should be 2: one in git diff polling (runAgentWithProgress) and one in updateToolsFromGit
 const pushMatches = [...source.matchAll(/_workflowFileChanges\.push\(/g)];
-assertEq(pushMatches.length, 1, "_workflowFileChanges.push 仅出现 1 次");
+assertEq(pushMatches.length, 2, "_workflowFileChanges.push 出现 2 次（轮询 + updateToolsFromGit）");
 
-// Verify the single push is inside updateToolsFromGit by checking
-// the function body of updateToolsFromGit contains the push.
+// Verify the push is inside updateToolsFromGit
 const updateToolsStart = source.indexOf("function updateToolsFromGit");
 const nextFuncStart = source.indexOf("function saveCheckpoint", updateToolsStart);
 const updateToolsBody = source.slice(updateToolsStart, nextFuncStart);
-const pushInUpdateTools = updateToolsBody.includes("_workflowFileChanges.push");
-assertTrue(pushInUpdateTools, "updateToolsFromGit 函数体内包含 _workflowFileChanges.push");
+assertTrue(updateToolsBody.includes("_workflowFileChanges.push"), "updateToolsFromGit 函数体内包含 _workflowFileChanges.push");
+
+// Verify the push is also inside the git diff polling (setInterval) in runAgentWithProgress
+const runAgentStart = source.indexOf("async function runAgentWithProgress");
+const runAgentEnd = source.indexOf("async function executeSingleStep", runAgentStart);
+const runAgentBody = source.slice(runAgentStart, runAgentEnd);
+assertTrue(runAgentBody.includes("_workflowFileChanges.push"), "git diff 轮询（setInterval）中包含 _workflowFileChanges.push");
 
 // ── Test J2: addWidgetSubStepTool 不再污染 _workflowFileChanges ──
 console.log("\n📋 测试 J2: addWidgetSubStepTool 不再污染 _workflowFileChanges\n");
@@ -677,7 +683,7 @@ const addWidgetFunc = source.slice(
 	source.indexOf("function addWidgetSubStepOutput")
 );
 const hasNoFileChangesRef = !addWidgetFunc.includes("_workflowFileChanges");
-assertTrue(hasNoFileChangesRef, "addWidgetSubStepTool 中不再引用 _workflowFileChanges");
+assertTrue(hasNoFileChangesRef, "addWidgetSubStepTool 函数体中不再引用 _workflowFileChanges");
 
 // ── Test J3: executeSingleStep 中不再有基于 _workflowFileChanges 的统计 ──
 console.log("\n📋 测试 J3: executeSingleStep 中不再有 '执行摘要' 类 chain context\n");
@@ -694,8 +700,11 @@ const loopGroupBody = source.slice(loopGroupStart);
 const hasNoCodeImplSummary = !loopGroupBody.includes('"代码实施摘要"') && !loopGroupBody.includes('"代码精简摘要"');
 assertTrue(hasNoCodeImplSummary, "executeLoopGroup 中不再有 '代码实施摘要' 或 '代码精简摘要' chain context");
 
-const hasNoReviewFeedbackKey = !loopGroupBody.includes('"代码审查反馈"') && !loopGroupBody.includes('"精简审查反馈"');
-assertTrue(hasNoReviewFeedbackKey, "executeLoopGroup 中不再有 '代码审查反馈' 或 '精简审查反馈' chain context");
+// Verify the removed review feedback keys are no longer present in updateChainContext calls
+// (comments may still reference them for historical context — that's fine)
+const chainCtxCallsLoop = [...loopGroupBody.matchAll(/updateChainContext\(`([^`]+)`/g)].map(m => m[1]);
+const reviewInCode = chainCtxCallsLoop.some(k => k.includes('代码审查反馈') || k.includes('精简审查反馈'));
+assertFalse(reviewInCode, "updateChainContext 中已不使用 '代码审查反馈' 或 '精简审查反馈' key");
 
 // ── Test J5: 工作总结条目在所有 agent 函数中仍保留 ──
 console.log("\n📋 测试 J5: '工作总结' 条目在所有 agent 函数中仍保留\n");
@@ -733,11 +742,14 @@ console.log("\n📋 测试 K3: outputPathPatterns 已简化\n");
 const hasOutputPathPatterns = source.includes("const outputPathPatterns = [");
 assertFalse(hasOutputPathPatterns, "outputPathPatterns 数组已移除（替换为 inline workflowId 过滤）");
 
-// ── Test K4: updateToolsFromGit 有 .pi-dev-output/ 过滤 ──
-console.log("\n📋 测试 K4: updateToolsFromGit 过滤 .pi-dev-output/\n");
+// ── Test K4: updateToolsFromGit 有 isWorkflowArtifactPath 过滤 ──
+console.log("\n📋 测试 K4: updateToolsFromGit 使用 isWorkflowArtifactPath 过滤\n");
+
+const hasIsWorkflowArtifactPath = source.includes('isWorkflowArtifactPath(change.path)');
+assertTrue(hasIsWorkflowArtifactPath, "updateToolsFromGit 使用 isWorkflowArtifactPath 跳过 .pi-dev-output/ 路径");
 
-const hasDotPiDevFilter = source.includes('change.path.startsWith(".pi-dev-output/")');
-assertTrue(hasDotPiDevFilter, "updateToolsFromGit 跳过 .pi-dev-output/ 路径");
+const hasIsWorkflowArtifactFunc = source.includes('function isWorkflowArtifactPath');
+assertTrue(hasIsWorkflowArtifactFunc, "isWorkflowArtifactPath 辅助函数存在");
 
 // ── Test K5: output 路径匹配使用 escapedId + workflowId ──
 console.log("\n📋 测试 K5: output 路径使用 workflowId 过滤\n");
@@ -751,15 +763,19 @@ console.log("\n📋 测试 K6: progress handler 使用 workflowId\n");
 const hasIncludesWorkflowId = source.includes("pathCandidate.includes(_workflowId)");
 assertTrue(hasIncludesWorkflowId, "progress handler 使用 pathCandidate.includes(_workflowId)");
 
-// ── Test K7: addWidgetSubStepTool 只来自 git diff + progress handler ──
-console.log("\n📋 测试 K7: addWidgetSubStepTool 只来自必要来源\n");
+// ── Test K7: addWidgetSubStepTool 只来自 git diff（regex 嗅探已移除）──
+console.log("\n📋 测试 K7: addWidgetSubStepTool 仅来自 git diff\n");
 
-// Verify the two known call sites exist:
-// 1. updateToolsFromGit: calls addWidgetSubStepTool with git status + path
-// 2. runAgentWithProgress progress handler: calls addWidgetSubStepTool with parsed toolMatch
-// Both are runtime call sites (not the function definition itself).
+// Verify the toolMatch regex sniffing has been removed (source 1)
+const hasToolMatchRegex = source.includes('const toolMatch = progress.match(/(edit|read|write|new|bash|grep|find|ls|delete|remove)');
+assertFalse(hasToolMatchRegex, "progress handler 中已移除 toolMatch 正则 (source 1)");
+
+// Verify the updateToolsFromGit call site still exists
 assertTrue(source.includes("addWidgetSubStepTool(stepIndex, agentName, `${change.status}   ${change.path}`)"), "updateToolsFromGit 调用 addWidgetSubStepTool");
-assertTrue(source.includes("addWidgetSubStepTool(stepIndex, agentName, `${gitStatus}   ${target}`)"), "progress handler 调用 addWidgetSubStepTool");
+
+// Verify git diff polling timer exists (replacement for regex sniffing)
+const hasGitPollTimer = source.includes('_gitPollTimer = setInterval');
+assertTrue(hasGitPollTimer, "git diff 轮询定时器已添加");
 
 // ── Test K8: addWidgetSubStepOutput 仍存在 (output 路径展示有用) ──
 console.log("\n📋 测试 K8: addWidgetSubStepOutput 仍保留\n");
@@ -769,6 +785,118 @@ assertTrue(hasAddWidgetOutput, "addWidgetSubStepOutput 函数声明仍保留");
 
 
 
+console.log("\n═══ Bug L 测试 — output 路径白名单验证 ═══\n");
+
+// ── Test L1: output 路径白名单验证 ──
+console.log("\n📋 测试 L1: output 路径白名单逻辑\n");
+
+function isValidOutputPath(path) {
+	return /^[\w.\/-]+$/.test(path) &&
+		path.length > 15 && path.length < 300 &&
+		path.includes("019e57e7");
+}
+
+// 应接受的合法路径
+assertTrue(isValidOutputPath(".pi-dev-output/pi-plans/20260524-test-019e57e7.md"), "合法路径应被接受");
+assertTrue(isValidOutputPath(".pi-dev-output/pi-review/md/review-20260524-019e57e7.md"), "review 路径应被接受");
+
+// 应拒绝的乱码路径
+assertFalse(isValidOutputPath(".pi-dev-output/pi-plans/中grepUUID\"019e57e7\"找到)"), "含中文路径应被拒绝");
+assertFalse(isValidOutputPath(".pi-dev-output/pi-plans/（测试）019e57e7.md"), "含括号路径应被拒绝");
+
+// ── Test L2: post-completion output 检测仅搜索 clean text ──
+console.log("\n📋 测试 L2: output 检测仅搜索 clean text（source 2 修复验证）\n");
+
+// 验证源代码中 outputPattern.exec 搜索的是 cleanText 而非 searchText
+const hasSearchTextOutput = source.includes('outputPattern.exec(searchText)');
+assertFalse(hasSearchTextOutput, "output 检测不再搜索 searchText (raw JSON)");
+
+// 验证替换为 cleanText
+const hasCleanTextOutput = source.includes('outputPattern.exec(cleanText)');
+assertTrue(hasCleanTextOutput, "output 检测搜索 cleanText (extracted text)");
+
+// ── Test L3: post-completion output 有白名单验证 ──
+console.log("\n📋 测试 L3: post-completion output 有白名单验证\n");
+
+const hasWhitelistCheck = source.includes('/^[\\w.\\/-]+\$/.test(path_)');
+assertTrue(hasWhitelistCheck, "post-completion output 检测包含 /^[\\w.\\/-]+\$/ 白名单验证");
+
+// ── Test L4: progress handler output 检测使用 whitelist regex ──
+console.log("\n📋 测试 L4: progress handler output 检测使用 whitelist regex\n");
+
+const hasProgressWhitelist = source.includes('.pi-dev-output\\/[a-zA-Z0-9_\\/\\.-]+');
+assertTrue(hasProgressWhitelist, "progress handler 使用 [a-zA-Z0-9_\\/\\.-]+ 白名单正则");
+
+// ── Test L5: isWorkflowArtifactPath 在 git diff 轮询中使用 ──
+console.log("\n📋 测试 L5: isWorkflowArtifactPath 在 git diff 轮询中使用\n");
+
+const hasPollIsWorkflowArtifact = source.includes('isWorkflowArtifactPath(change.path)');
+assertTrue(hasPollIsWorkflowArtifact, "git diff 轮询使用 isWorkflowArtifactPath 过滤");
+
+// ── Test L6: git diff 轮询也向 _workflowFileChanges 推送 ──
+console.log("\n📋 测试 L6: git diff 轮询向 _workflowFileChanges 推送\n");
+
+// Verify the polling code pushes to _workflowFileChanges before addWidgetSubStepTool
+const pollTimerBodyStart = source.indexOf('_gitPollTimer = setInterval');
+const pollTimerBodyEnd = source.indexOf('_gitPollTimer.unref()');
+const pollTimerBody = source.slice(pollTimerBodyStart, pollTimerBodyEnd);
+const hasPushInPoll = pollTimerBody.includes('_workflowFileChanges.push');
+assertTrue(hasPushInPoll, "git diff 轮询（setInterval）中包含 _workflowFileChanges.push");
+
+// Verify the type mapping (A→new, D→delete, else→edit) exists in polling code
+const hasTypeMappingInPoll = pollTimerBody.includes('change.status === "A" ? "new"');
+assertTrue(hasTypeMappingInPoll, "git diff 轮询中文件变更的类型映射正确");
+
+
+
+// ── Test L7: _pollSeen 使用 path:stepIndex 而非 status:path ──
+console.log("\n📋 测试 L7: _pollSeen 使用 path:stepIndex 而非 status:path\n");
+
+// 验证轮询代码不再使用 status:path 作为键
+const hasStatusPathKeyInPoll = source.includes('const key = `\${change.status}:\${change.path}`');
+assertFalse(hasStatusPathKeyInPoll, "_pollSeen 不使用 status:path 作为键");
+
+// 验证轮询代码使用 path:stepIndex 作为键
+const hasPathStepKeyInPoll = source.includes('const key = `\${change.path}:\${stepIndex}`');
+assertTrue(hasPathStepKeyInPoll, "_pollSeen 使用 path:stepIndex 作为键");
+
+
+// ── Test L8: toGitStatus 函数已删除 ──
+console.log("\n📋 测试 L8: toGitStatus 函数已删除（无调用者死代码）\n");
+
+const hasToGitStatusFunc = source.includes("function toGitStatus(");
+assertFalse(hasToGitStatusFunc, "toGitStatus 函数已删除");
+
+const hasToGitStatusRef = source.includes("toGitStatus");
+assertFalse(hasToGitStatusRef, "toGitStatus 无任何引用残留");
+
+
+// ── Test L9: updateToolsFromGit 不再有 pollSeen 参数 ──
+console.log("\n📋 测试 L9: updateToolsFromGit 不再有 pollSeen 死代码参数\n");
+
+const hasPollSeenParam = source.includes("pollSeen?: Set<string>");
+assertFalse(hasPollSeenParam, "updateToolsFromGit 无 pollSeen 参数");
+
+const hasPollSeenCheck = source.includes("pollSeen?.has(");
+assertFalse(hasPollSeenCheck, "updateToolsFromGit 无 pollSeen?.has() 检查");
+
+const hasPollSeenPass = source.includes("updateToolsFromGit(_workflowCwd, stepIndex, agentName, _pollSeen)");
+assertFalse(hasPollSeenPass, "updateToolsFromGit 调用处无 _pollSeen 参数传递");
+
+
+// ── Test L10: post-completion output 正则使用白名单字符类 ──
+console.log("\n📋 测试 L10: post-completion output 正则使用白名单字符类\n");
+
+// 验证 post-completion outputPattern 使用白名单 [a-zA-Z0-9] 而非排除法 [^...]
+const hasPostCompletionWhitelist = source.includes("outputPattern = new RegExp(\`\\\\.pi-dev-output\\\\/[a-zA-Z0-9_\\\\/.-]");
+assertTrue(hasPostCompletionWhitelist, "post-completion output 正则使用 [a-zA-Z0-9_\\\\/.-] 白名单字符类");
+
+// 验证不再使用排除字符类 (用反确认方式)
+const hasNegatedClassOutput = source.includes("\\[^\\\\s,;)\\\\]}");
+const hasNegatedClassOutput2 = source.includes("[^\\\\s,;)\\\\]}");
+assertFalse(hasNegatedClassOutput || hasNegatedClassOutput2, "post-completion output 正则不使用排除法 [^\\\\s,;)\\\\]}");
+
+
 console.log("\n═══════════════════════════════════════════════════════\n");
 console.log(`📊 结果: ${pass} 通过, ${fail} 失败\n`);