@zhushanwen/pi-subagent-workflow 5.0.2 → 7.0.0

package/src/injectors/workflow-list-injector.ts

@@ -15,13 +15,15 @@
  *   注入每 turn 会膨胀 prompt）
  */
 
-import * as fs from "node:fs";
+
 
 import type {
 	BeforeAgentStartEvent,
 	BeforeAgentStartEventResult,
 	ExtensionAPI,
 	ExtensionContext,
+	SessionShutdownEvent,
+	SessionStartEvent,
 } from "@earendil-works/pi-coding-agent";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { getLogger } from "@zhushanwen/pi-extension-logger";
@@ -29,20 +31,30 @@ import { getLogger } from "@zhushanwen/pi-extension-logger";
 import {
 	discoverResources,
 	findWorkspaceRoot,
+	getCachedFileContent,
 } from "../shared/resource-discovery.ts";
+import { parseResourceMeta } from "../shared/meta-parser.ts";
 
 const logger = getLogger("injector");
 
+/**
+ * Session 级 workflow 列表缓存（per-process = per-session），与 agentCache 对称。
+ * 见 subagent-list-injector.ts 的 agentCache 注释。
+ */
+let workflowCache: WorkflowEntry[] | null = null;
+
 /** 注入段中单个 workflow 的最大描述长度（控制每 turn prompt 体积） */
 const MAX_DESC_LEN = 160;
 
 /** 断句阈值比例：句末标点位置须 >= maxLen 的 40% 才采用，否则硬截断保留更多信息 */
 const DESC_BOUNDARY_MIN_RATIO = 0.4;
 
-/** 解析后的 workflow 条目（name + 截断后的 description） */
+/** 解析后的 workflow 条目（name + 截断后的 description + agentRef 路径） */
 export interface WorkflowEntry {
 	name: string;
 	description: string;
+	/** workflowRef：脚本 .js 文件的绝对路径（注入段 <location>，模型直接引用） */
+	path: string;
 }
 
 /**
@@ -68,46 +80,17 @@ export function summarizeDescription(
 }
 
 /**
- * 从源码中提取 `const meta = { ... }` 块（花括号配平）。
- * 无 meta 块返回 null。
- */
-function extractMetaBlock(src: string): string | null {
-	const startMatch = src.match(/const\s+meta\s*=\s*\{/);
-	if (!startMatch || startMatch.index === undefined) return null;
-	const afterOpen = startMatch.index + startMatch[0].length;
-	let depth = 1;
-	let i = afterOpen;
-	while (i < src.length && depth > 0) {
-		const ch = src[i];
-		if (ch === "{") depth++;
-		else if (ch === "}") depth--;
-		i++;
-	}
-	if (depth !== 0) return null;
-	return src.slice(startMatch.index, i);
-}
-
-/** 从 meta 块中提取单行字符串字段值（双引号或单引号包裹）。 */
-function extractMetaField(block: string, field: string): string | null {
-	const re = new RegExp(`^[ \\t]*${field}:\\s*("([^"]*)"|'([^']*)')`, "m");
-	const m = block.match(re);
-	if (!m) return null;
-	return m[2] ?? m[3] ?? null;
-}
-
-/**
- * 解析 workflow .js/.mjs 文件的 meta 对象（name + description）。
+ * 解析 workflow .js 文件的 meta（name + description），经 IF1 parseResourceMeta。
  *
- * 所有 builtin workflow 均声明 `const meta = { name, description, phases }`，
- * description 为单行字符串。缺 name 或 description 返回 null。
+ * m2 收敛：删 extractMetaBlock/extractMetaField（本地 brace-match parser），
+ * 改调 shared/meta-parser.ts parseResourceMeta（统一 parser）。仅认 @pi-meta 新格式。
+ * 投影到 WorkflowEntry {name, description(summarized)} 注入用。
  */
 export function parseWorkflowMeta(content: string): WorkflowEntry | null {
-	const block = extractMetaBlock(content);
-	if (!block) return null;
-	const name = extractMetaField(block, "name");
-	const description = extractMetaField(block, "description");
-	if (!name || !description) return null;
-	return { name, description: summarizeDescription(description) };
+	const meta = parseResourceMeta(content, "workflow");
+	if (!meta || meta.kind !== "workflow") return null;
+	// path 由 discoverAllWorkflows 从 DiscoveredResource.path 填充
+	return { name: meta.name, description: summarizeDescription(meta.description), path: "" };
 }
 
 /**
@@ -129,9 +112,9 @@ export async function discoverAllWorkflows(
 	for (const resource of resources) {
 		if (!resource.available) continue;
 		try {
-			const content = fs.readFileSync(resource.path, "utf8");
+			const content = getCachedFileContent(resource.path) ?? "";
 			const wf = parseWorkflowMeta(content);
-			if (wf) map.set(wf.name, wf);
+			if (wf) map.set(wf.name, { ...wf, path: resource.path });
 		} catch (err) {
 			logger.error(
 				`[workflow-list-injector] skip unreadable workflow file ${resource.path}`,
@@ -164,11 +147,13 @@ export function formatWorkflowList(workflows: WorkflowEntry[]): string {
 
 	const lines = [
 		"\n\n<available_workflows>",
-		'The following workflows are available. Do NOT call list to discover available workflows — they are listed below; use list only for running state. Built-in workflows (chain/parallel/scatter-gather/map-reduce/review-fix-loop) run directly.',
+		// 引导语与具体 workflow 解耦：不写死内置名（列表本身已含全部 workflow，
+		// 名字/描述每 turn 由 @pi-meta 动态注入），只给通用路由指引 + read location 参数指针。
+		'The following workflows are available. Do NOT call list to discover available workflows — they are listed below; use list only for running state. All listed workflows run directly via action:run — do NOT use workflow-script generate for any listed workflow. For parameter details, read the <location> script file (script header has @pi-meta parameters + usage).',
 	];
 	for (const wf of workflows) {
 		lines.push(
-			`  <workflow><name>${escapeXml(wf.name)}</name><description>${escapeXml(wf.description)}</description></workflow>`,
+			`  <workflow><name>${escapeXml(wf.name)}</name><description>${escapeXml(wf.description)}</description><location>${escapeXml(wf.path)}</location></workflow>`,
 		);
 	}
 	lines.push("</available_workflows>");
@@ -176,10 +161,30 @@ export function formatWorkflowList(workflows: WorkflowEntry[]): string {
 }
 
 /**
- * 注册 before_agent_start handler，注入 `<available_workflows>` 段。
- * 与 setupSubagentListInjector 链式（pi 串联多 handler 的 systemPrompt 返回值）。
+ * 注册 session 生命周期 handler，注入 `<available_workflows>` 段。
+ *
+ * 与 setupSubagentListInjector 对称：session_start 发现+缓存，before_agent_start
+ * 读缓存（miss fallback）渲染注入，session_shutdown 清缓存。与 subagent 注入
+ * handler 链式（pi 串联多 handler 的 systemPrompt 返回值）。
  */
 export function setupWorkflowListInjector(pi: ExtensionAPI): void {
+	pi.on(
+		"session_start",
+		async (_event: SessionStartEvent, ctx: ExtensionContext): Promise<void> => {
+			try {
+				workflowCache = await discoverAllWorkflows(
+					findWorkspaceRoot(ctx.cwd),
+					getAgentDir(),
+				);
+			} catch (err) {
+				// fail-safe：发现异常不阻断 session，缓存保持 null（before_agent_start 会 fallback）
+				logger.error("[workflow-list-injector] session_start discover failed", {
+					reason: err instanceof Error ? err.message : String(err),
+				});
+			}
+		},
+	);
+
 	pi.on(
 		"before_agent_start",
 		async (
@@ -187,11 +192,14 @@ export function setupWorkflowListInjector(pi: ExtensionAPI): void {
 			ctx: ExtensionContext,
 		): Promise<BeforeAgentStartEventResult | void> => {
 			try {
-				const workflows = await discoverAllWorkflows(
-					findWorkspaceRoot(ctx.cwd),
-					getAgentDir(),
-				);
-				const injection = formatWorkflowList(workflows);
+				// 读缓存；miss（session_start 未触发/缓存被清）则 fallback 重新发现+赋值
+				if (workflowCache === null) {
+					workflowCache = await discoverAllWorkflows(
+						findWorkspaceRoot(ctx.cwd),
+						getAgentDir(),
+					);
+				}
+				const injection = formatWorkflowList(workflowCache);
 				if (!injection) return;
 				return { systemPrompt: event.systemPrompt + injection };
 			} catch (err) {
@@ -201,4 +209,11 @@ export function setupWorkflowListInjector(pi: ExtensionAPI): void {
 			}
 		},
 	);
+
+	pi.on(
+		"session_shutdown",
+		(_event: SessionShutdownEvent, _ctx: ExtensionContext): void => {
+			workflowCache = null;
+		},
+	);
 }

package/src/interface/__tests__/detectors.test.ts

@@ -14,80 +14,137 @@
 
 import { describe, expect, it } from "vitest";
 
-import { findFlattenedArgKeys } from "../tool-workflow";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { argKeysFromMeta, findFlattenedArgKeys } from "../tool-workflow";
+import { parseResourceMeta } from "../../shared/meta-parser.ts";
+
+// 真实参数集（argKeysFromMeta 产物——m6 动态数据源，与 TC2 同源防漂移）
+function rflKeys() {
+  const src = readFileSync(join(__dirname, "../../../workflows/review-fix-loop.js"), "utf-8");
+  const meta = parseResourceMeta(src, "workflow");
+  if (!meta || meta.kind !== "workflow" || !meta.parameters) throw new Error("rfl meta");
+  return argKeysFromMeta(meta.parameters);
+}
+function chainKeys() {
+  const src = readFileSync(join(__dirname, "../../../workflows/chain.js"), "utf-8");
+  const meta = parseResourceMeta(src, "workflow");
+  if (!meta || meta.kind !== "workflow" || !meta.parameters) throw new Error("chain meta");
+  return argKeysFromMeta(meta.parameters);
+}
+const RFL = rflKeys();
+const CHAIN = chainKeys();
 
 describe("findFlattenedArgKeys (workflow args flatten detector — P0)", () => {
-  it("triggers when args sub-fields flattened to top level", () => {
-    expect(findFlattenedArgKeys({ action: "run", name: "chain", task: "x" })).toEqual(["task"]);
-    expect(findFlattenedArgKeys({ action: "run", name: "x", items: ["a"] })).toEqual(["items"]);
+  it("TC3a: trigger——chain 参数集平铺 task 被识别；跨 workflow 区分（items 非 chain 参数不触发）", () => {
     expect(
-      findFlattenedArgKeys({ action: "run", name: "x", task: "t", perspectives: ["p"] }),
-    ).toEqual(["task", "perspectives"]);
+      findFlattenedArgKeys({ action: "run", name: "chain", task: "x" }, CHAIN.exact, CHAIN.patterns),
+    ).toEqual(["task"]);
+    // 跨 workflow：items 是 map-reduce 参数非 chain 参数 → 不触发（m6 动态集语义）
+    expect(
+      findFlattenedArgKeys({ action: "run", name: "chain", items: ["a"] }, CHAIN.exact, CHAIN.patterns),
+    ).toEqual([]);
   });
 
-  it("does NOT trigger when fields correctly nested in args", () => {
+  it("TC3b: 嵌套 args 不触发", () => {
     expect(
-      findFlattenedArgKeys({ action: "run", name: "x", args: { task: "x", items: ["a"] } }),
+      findFlattenedArgKeys({ action: "run", name: "x", args: { task: "x", items: ["a"] } }, CHAIN.exact, CHAIN.patterns),
     ).toEqual([]);
   });
 
-  it("edge: key present at BOTH top-level and inside args is NOT flagged", () => {
-    // 同时传 args.task 和顶层 task：args 已提供，顶层冗余被忽略，不算平铺。
-    // 这是 reviewer 点名的 untested edge。
+  it("TC3c: 顶层 + args 内共存不触发（args-排除保留）", () => {
     expect(
-      findFlattenedArgKeys({ action: "run", name: "x", args: { task: "x" }, task: "y" }),
+      findFlattenedArgKeys({ action: "run", name: "x", args: { task: "x" }, task: "y" }, CHAIN.exact, CHAIN.patterns),
     ).toEqual([]);
   });
 
-  it("does NOT trigger when no known arg keys present", () => {
-    expect(findFlattenedArgKeys({ action: "run", name: "x", args: {} })).toEqual([]);
-    expect(findFlattenedArgKeys({ action: "status" })).toEqual([]);
+  it("TC3d: 无已知键不触发；空集不触发", () => {
+    expect(
+      findFlattenedArgKeys({ action: "run", name: "x", args: {} }, CHAIN.exact, CHAIN.patterns),
+    ).toEqual([]);
+    expect(
+      findFlattenedArgKeys({ action: "status" }, new Set(), []),
+    ).toEqual([]);
   });
 
-  it("review-fix-loop fixAgent 平铺被识别（TC7）", () => {
-    expect(findFlattenedArgKeys({ action: "run", name: "review-fix-loop", fixAgent: "worker" })).toEqual(["fixAgent"]);
+  it("TC3e: review-fix-loop fixAgent 平铺被识别（动态集 exact）", () => {
     expect(
-      findFlattenedArgKeys({ action: "run", name: "review-fix-loop", args: { fixAgent: "worker" } }),
+      findFlattenedArgKeys({ action: "run", name: "review-fix-loop", fixAgent: "worker" }, RFL.exact, RFL.patterns),
+    ).toEqual(["fixAgent"]);
+    expect(
+      findFlattenedArgKeys({ action: "run", name: "review-fix-loop", args: { fixAgent: "worker" } }, RFL.exact, RFL.patterns),
     ).toEqual([]);
   });
 
-  it("triggers for review-fix-loop args flattened to top level (incl. batchN prefix)", () => {
+  it("TC3f: batchN 经 pattern 触发 + batchl 拼错不触发（数字后缀语义）", () => {
     expect(
-      findFlattenedArgKeys({ action: "run", name: "review-fix-loop", targetType: "git-diff", target: "main" }),
+      findFlattenedArgKeys(
+        { action: "run", name: "review-fix-loop", targetType: "git-diff", target: "main" },
+        RFL.exact,
+        RFL.patterns,
+      ),
     ).toEqual(["targetType", "target"]);
     expect(
-      findFlattenedArgKeys({ action: "run", name: "review-fix-loop", batch1: "reviewer", autoCommit: true }),
+      findFlattenedArgKeys(
+        { action: "run", name: "review-fix-loop", batch1: "reviewer", autoCommit: true },
+        RFL.exact,
+        RFL.patterns,
+      ),
     ).toEqual(["batch1", "autoCommit"]);
     expect(
-      findFlattenedArgKeys({ action: "run", name: "review-fix-loop", args: { targetType: "git-diff", target: "main" } }),
+      findFlattenedArgKeys(
+        { action: "run", name: "review-fix-loop", args: { targetType: "git-diff", target: "main" } },
+        RFL.exact,
+        RFL.patterns,
+      ),
+    ).toEqual([]);
+    // batchl 拼错（非数字后缀）不触发（m6 评审 C-1：pattern 自带数字后缀校验）
+    expect(
+      findFlattenedArgKeys({ action: "run", name: "x", batchl: "reviewer" }, RFL.exact, RFL.patterns),
     ).toEqual([]);
-    // 未知键（如 batchl 拼错）不属于白名单，不触发平铺检测（由 workflow 内白名单校验报错）
-    expect(findFlattenedArgKeys({ action: "run", name: "x", batchl: "reviewer" })).toEqual([]);
   });
 
-  it("review-fix-loop 收敛/模型参数平铺被识别（S-13 补全 4 键）", () => {
+  it("TC3g: 收敛参数平铺被识别（动态集 exact——S-13 3 键，model 升格 TOOL_TOP_LEVEL 后排除）", () => {
     expect(
-      findFlattenedArgKeys({
-        action: "run",
-        name: "review-fix-loop",
-        model: "ds-flash",
-        maxFixAttempts: 3,
-        convergeNewIssues: 2,
-        convergeRounds: 3,
-      }),
-    ).toEqual(["model", "maxFixAttempts", "convergeNewIssues", "convergeRounds"]);
+      findFlattenedArgKeys(
+        { action: "run", name: "review-fix-loop", model: "ds-flash", maxFixAttempts: 3, convergeNewIssues: 2, convergeRounds: 3 },
+        RFL.exact,
+        RFL.patterns,
+      ),
+    ).toEqual(["maxFixAttempts", "convergeNewIssues", "convergeRounds"]);
     expect(
-      findFlattenedArgKeys({
-        action: "run",
-        name: "review-fix-loop",
-        args: { model: "ds-flash", maxFixAttempts: 3 },
-        convergeRounds: 3,
-      }),
+      findFlattenedArgKeys(
+        { action: "run", name: "review-fix-loop", args: { model: "ds-flash", maxFixAttempts: 3 }, convergeRounds: 3 },
+        RFL.exact,
+        RFL.patterns,
+      ),
     ).toEqual(["convergeRounds"]);
   });
 
-  it("returns [] for non-object input", () => {
-    expect(findFlattenedArgKeys(null)).toEqual([]);
-    expect(findFlattenedArgKeys(undefined)).toEqual([]);
+  it("TC3h: non-object 输入返回 []", () => {
+    expect(findFlattenedArgKeys(null, new Set(), [])).toEqual([]);
+    expect(findFlattenedArgKeys(undefined, new Set(), [])).toEqual([]);
+  });
+
+  it("TC3i: tool 顶层键不误报（M-3 回归——合成 parameters 直测 argKeysFromMeta 排除）", () => {
+    // 合成 parameters：workflow 声明参数 name（tool 键撞名）——argKeysFromMeta 必须排除
+    const keys = argKeysFromMeta({
+      type: "object",
+      properties: { name: { type: "string" }, task: { type: "string" } },
+      required: ["name"],
+    });
+    expect(keys.exact.has("task")).toBe(true);
+    expect(keys.exact.has("name")).toBe(false); // TOOL_TOP_LEVEL 排除（M-3 真回归锁定）
+    // 合法调用不误报
+    expect(
+      findFlattenedArgKeys(
+        { action: "run", name: "mywf", args: { name: "x" } },
+        keys.exact,
+        keys.patterns,
+      ),
+    ).toEqual([]);
+    // 真实 meta 不含 name（探针实测 16 键）——附加验证
+    expect(RFL.exact.has("name")).toBe(false);
   });
 });

package/src/interface/__tests__/subagent-tool-prompt.test.ts

@@ -101,18 +101,14 @@ describe("subagent tool description — 行为约束器（非功能说明书）"
     expect(DESCRIPTION).not.toContain('"sa_');
   });
 
-  it("agent 枚举（schema 字段 description）包含全部 9 个内置 agent（含 orchestrator，防漏）", () => {
-    // 包内有 9 个 agent .md（含 orchestrator）。schema 的 agent 字段 description 必须全部列出，
-    // 否则 LLM 无法选中未列出的 agent（功能回归）。cr-fix 防回归锁定。
-    // 注意：agent 列表在 schema field description 里，不在主 description: 模板字符串里——
-    // 断言源码全文（含 schema field description）而非 DESCRIPTION。
-    const expected = [
-      "general-purpose", "worker", "researcher", "explorer",
-      "planner", "reviewer", "oracle", "context-builder", "orchestrator",
-    ];
-    for (const name of expected) {
-      expect(SUBAGENT_TOOL_SRC).toContain(name);
-    }
+  it("agent 字段 description 不写死枚举，指向 <available_subagents>（通用化防漂移）", () => {
+    // 原实现把 9 个内置 agent 名写死在 schema field description（防漏），
+    // 但枚举与包内 agents/*.md 存在漂移风险（新增/删除 agent 要手改两处）。
+    // 现改为指向每 turn 动态注入的 <available_subagents> 列表——防漏职责由注入段承担，
+    // 工具描述只保留通用指引（2026-08 通用化重构）。
+    expect(SUBAGENT_TOOL_SRC).toContain("available_subagents");
+    // 通用化约束：不写死任何具体 agent 名（名字随 agents/*.md 动态变化）
+    expect(SUBAGENT_TOOL_SRC).not.toMatch(/orchestrator|code-reviewer|context-builder/);
   });
 
   it("Anti-patterns 段明确 list/cancel 仍 nested（防过度泛化 flatten）", () => {

package/src/interface/__tests__/tool-workflow-script-generate.test.ts

@@ -0,0 +1,163 @@
+/**
+ * actionGenerate 行为测试（m0 wave / TC1-TC7 + [P-generate-roundtrip]）
+ *
+ * mock node:fs（mkdirSync/writeFileSync）避免真实落盘 .pi/workflows/.tmp/。
+ * parseResourceMetaDetailed 真实调用（不 mock m1）——round-trip 探针必须用真实 IF2。
+ *
+ * 框架：vitest（禁 node:test）。
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { actionGenerate, type ScriptParams, type TextContent } from "../tool-workflow-script.ts";
+
+vi.mock("node:fs", () => ({
+  mkdirSync: vi.fn(),
+  writeFileSync: vi.fn(),
+}));
+
+const mockedWriteFileSync = vi.mocked(writeFileSync);
+const mockedMkdirSync = vi.mocked(mkdirSync);
+
+function gen(script: string, name = "test-wf"): ScriptParams {
+  return { action: "generate", name, script } as ScriptParams;
+}
+
+/** TextContent.text 在 content[0].text。 */
+function textOf(r: TextContent): string {
+  return r.content[0]?.text ?? "";
+}
+
+const PI_META_VALID = `/* @pi-meta
+name: test-wf
+description: 合法新格式
+phases: [a, b]
+parameters:
+  type: object
+  properties:
+    task: { type: string }
+  required: [task]
+*/
+const agent = require("./agent");
+agent("worker", { task: $ARGS.task });
+`;
+
+const PI_META_MALFORMED = `/* @pi-meta
+name: test-wf
+description: bad
+  broken: indent
+phases: [a]
+*/
+const agent = require("./agent");
+agent("w");
+`;
+
+const PI_META_REGEX_SINGLE_BS = `/* @pi-meta
+name: test-wf
+description: regex
+phases: [A]
+parameters:
+  type: object
+  patternProperties:
+    "^batch\\d+$": { type: string }
+*/
+const agent = require("./agent");
+agent("w");
+`;
+
+const LEGACY_CONST_META = `const meta = {
+  name: test-wf,
+  description: legacy,
+  phases: ["a"]
+};
+const agent = require("./agent");
+agent("w");
+`;
+
+const NO_META = `const agent = require("./agent");
+agent("w");
+`;
+
+const ESM_IMPORT = `/* @pi-meta
+name: x
+description: d
+phases: [a]
+*/
+import { foo } from "bar";
+const agent = require("./agent");
+agent("w");
+`;
+
+const NO_AGENT = `/* @pi-meta
+name: x
+description: d
+phases: [a]
+*/
+const x = 1;
+`;
+
+describe("actionGenerate (m0: @pi-meta 认可 + round-trip)", () => {
+  beforeEach(() => {
+    mockedWriteFileSync.mockClear();
+    mockedMkdirSync.mockClear();
+  });
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("TC1: 合法 @pi-meta → ready + writeFileSync 被调用", () => {
+    const r = actionGenerate(gen(PI_META_VALID), undefined);
+    expect(r.isError).toBeFalsy();
+    expect(textOf(r)).toMatch(/ready|generated|test-wf/i);
+    expect(mockedWriteFileSync).toHaveBeenCalledTimes(1);
+  });
+
+  it("TC2: malformed @pi-meta YAML → error + writeFileSync 未调用 [P-generate-roundtrip]", () => {
+    const r = actionGenerate(gen(PI_META_MALFORMED), undefined);
+    expect(r.isError).toBe(true);
+    expect(textOf(r)).toMatch(/cannot be parsed|无法解析|line/i);
+    expect(mockedWriteFileSync).not.toHaveBeenCalled();
+  });
+
+  it("TC3: legacy const meta（过渡期）→ ready + writeFileSync 被调用", () => {
+    const r = actionGenerate(gen(LEGACY_CONST_META), undefined);
+    expect(r.isError).toBeFalsy();
+    expect(mockedWriteFileSync).toHaveBeenCalledTimes(1);
+  });
+
+  it("TC4: 无 meta → error 提及 @pi-meta 新格式", () => {
+    const r = actionGenerate(gen(NO_META), undefined);
+    expect(r.isError).toBe(true);
+    expect(textOf(r)).toMatch(/meta declaration/i);
+    expect(textOf(r)).toMatch(/pi-meta/i);
+    expect(mockedWriteFileSync).not.toHaveBeenCalled();
+  });
+
+  it("TC5: @pi-meta 单反斜杠正则 → error（LLM 高频错）[P-generate-roundtrip]", () => {
+    const r = actionGenerate(gen(PI_META_REGEX_SINGLE_BS), undefined);
+    expect(r.isError).toBe(true);
+    expect(textOf(r)).toMatch(/escape|cannot be parsed|无法解析|line/i);
+    expect(mockedWriteFileSync).not.toHaveBeenCalled();
+  });
+
+  it("TC6: ESM import → reject（保留现有行为）", () => {
+    const r = actionGenerate(gen(ESM_IMPORT), undefined);
+    expect(r.isError).toBe(true);
+    expect(textOf(r)).toMatch(/ESM|import/i);
+  });
+
+  it("TC7: 无 agent() → reject（保留现有行为）", () => {
+    const r = actionGenerate(gen(NO_AGENT), undefined);
+    expect(r.isError).toBe(true);
+    expect(textOf(r)).toMatch(/agent\(\)/i);
+  });
+
+  it("TC8: signal aborted → reject（保留现有行为）", () => {
+    const controller = new AbortController();
+    controller.abort();
+    const r = actionGenerate(gen(PI_META_VALID), controller.signal);
+    expect(r.isError).toBe(true);
+    expect(textOf(r)).toMatch(/abort/i);
+  });
+});

package/src/interface/__tests__/workflow-tool-prompt.test.ts

@@ -23,13 +23,46 @@ const TOOL_WORKFLOW_SCRIPT_SRC = readFileSync(
   "utf-8",
 );
 
+/** 截取 promptGuidelines 数组文本——防 KNOWN_ARG_KEYS 等注释/代码中的裸词污染断言。
+ * 数到数组闭合（跳过字符串字面量内的括号，exec-review F9：'],' 序列静默截断）。 */
+function promptGuidelinesText(src: string): string {
+  const start = src.indexOf("promptGuidelines: [");
+  let depth = 0;
+  let inStr = false;
+  for (let i = start; i < src.length; i++) {
+    const ch = src[i];
+    if (inStr) {
+      if (ch === "\\") { i++; continue; }
+      if (ch === '"') inStr = false;
+      continue;
+    }
+    if (ch === '"') inStr = true;
+    else if (ch === "[") depth++;
+    else if (ch === "]") {
+      depth--;
+      if (depth === 0) return src.slice(start, i + 1);
+    }
+  }
+  return src.slice(start);
+}
+
 describe("U1: workflow tool prompt mentions built-in workflows", () => {
-  it("tool-workflow.ts description 或 promptGuidelines 含 4 个内置 workflow 名称", () => {
-    // 4 个内置通用编排 workflow 必须在提示词里出现，LLM 才能发现并使用。
-    expect(TOOL_WORKFLOW_SRC).toContain("chain");
-    expect(TOOL_WORKFLOW_SRC).toContain("parallel");
-    expect(TOOL_WORKFLOW_SRC).toContain("scatter-gather");
-    expect(TOOL_WORKFLOW_SRC).toContain("map-reduce");
+  it("TC4a: promptGuidelines 不含具体内置 args 枚举（m4 瘦身——参数知识在 read location）", () => {
+    // m4：BUILT-IN 枚举删除，发现职责转移给 <available_workflows> 注入段 + read location。
+    // 截取 promptGuidelines 段断言（"batch1..batchN" 等在 KNOWN_ARG_KEYS 注释中出现）。
+    const guidelines = promptGuidelinesText(TOOL_WORKFLOW_SRC);
+    expect(guidelines).not.toContain("chain (sequential");
+    expect(guidelines).not.toContain("args: task");
+    expect(guidelines).not.toContain("batch1..batchN");
+    expect(guidelines).not.toContain("chain/parallel/scatter-gather/map-reduce");
+  });
+
+  it("TC4b: promptGuidelines 引导 read location 获取参数细节（info 已砍，ADR-0003 D5）", () => {
+    const guidelines = promptGuidelinesText(TOOL_WORKFLOW_SRC);
+    expect(guidelines).toContain("read the <location>");
+    expect(guidelines).toContain("script file");
+    // info action 已砍，引导语不再含 workflow info
+    expect(guidelines).not.toContain("workflow info");
   });
 
   it("tool-workflow.ts promptGuidelines 含 workflow-script list 交叉引用", () => {
@@ -58,11 +91,14 @@ describe("U1: workflow tool prompt mentions built-in workflows", () => {
     expect(TOOL_WORKFLOW_SRC).toContain("top level");
   });
 
-  it("runtime handler 错误文案含 Correct 纠正正例 + 平铺检测", () => {
+  it("runtime handler 错误文案含 Correct 纠正正例 + 平铺检测（m6：动态参数集）", () => {
     // 读源码文本断言 actionRun/必填校验的错误文案含 Correct 正例，
-    // 让弱模型撞错后第二次能直接照抄正确形态。KNOWN_ARG_KEYS 证明平铺检测存在。
+    // 让弱模型撞错后第二次能直接照抄正确形态。m6 后平铺检测数据源为动态
+    // argKeysFromMeta（schema 即 SSOT）——断言新机制存在（KNOWN_ARG_KEYS 已删）。
     expect(TOOL_WORKFLOW_SRC).toContain("Correct:");
-    expect(TOOL_WORKFLOW_SRC).toContain("KNOWN_ARG_KEYS");
+    expect(TOOL_WORKFLOW_SRC).toContain("findFlattenedArgKeys");
+    expect(TOOL_WORKFLOW_SRC).toContain("argKeysFromMeta");
+    expect(TOOL_WORKFLOW_SRC).not.toMatch(/const\s+KNOWN_ARG_KEYS/);
   });
 
   it("tool-workflow-script.ts list action 的 promptGuidelines 含 workflow run 交叉引用", () => {
@@ -80,4 +116,14 @@ describe("U1: workflow tool prompt mentions built-in workflows", () => {
     expect(TOOL_WORKFLOW_SCRIPT_SRC).toContain("CRITICAL ANTI-PATTERN");
     expect(TOOL_WORKFLOW_SCRIPT_SRC).toContain("NEVER generate");
   });
+
+  it("promptGuidelines + parameter description 标注 budget 默认不限制（B/C：除非用户要求否则别设）", () => {
+    // budget 是 run 级参数，运行时 maxTokens===undefined → 不限制（budget.ts isExceeded 守卫）。
+    // 但 call shape 示例展示了 tokens/time 字段，LLM 会误以为每次都该填。
+    // promptGuidelines 必须明确 "Do NOT set ... unless user explicitly requests",
+    // parameter description 同步标 "omit = unlimited"，双重约束压过示例的反引导。
+    const guidelines = promptGuidelinesText(TOOL_WORKFLOW_SRC);
+    expect(guidelines).toContain("Do NOT set tokens/time unless the user explicitly requests");
+    expect(TOOL_WORKFLOW_SRC).toContain("omit = unlimited (default)");
+  });
 });