@ghyper9023/pi-dev-workflow 0.6.0 → 0.6.1

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/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.1",
   "keywords": [
     "pi-package"
   ],

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`);