@zhushanwen/pi-subagent-workflow 8.7.0 → 8.8.1

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

@@ -1,5 +1,5 @@
 /**
- * Workflow List Injector（B2 / P1）
+ * Workflow List Injector（B2 / P1；C5① 渲染改接 core）
  *
  * 发现所有可用 workflow（.js/.mjs）并通过 before_agent_start 每 turn 注入
  * `<available_workflows>` 段（name + description），与 subagent 注入段对称。
@@ -8,220 +8,60 @@
  * 与 subagent 不对称。补全后模型可直接 `run` 已列出的 workflow，无需先 list。
  *
  * 实现要点：
- * - 发现走同包 ADR-031 统一发现 discoverResources({kind:"workflows", includeTmp:true})
- *   （includeTmp 覆盖 .pi/workflows/.tmp/，即 workflow-script generate 的产物）
- * - 解析每个 workflow 的 `const meta = {name, description, ...}` 提取 name+description
- * - description 截断为 prompt 友好的摘要（builtin 的 review-fix-loop 描述超长，全量
- *   注入每 turn 会膨胀 prompt）
+ * - D7-②（dual-track convergence）：同构骨架（缓存对/唯一写点/三 handler）收敛到
+ *   同目录 resource-list-injector.ts 工厂，本文件只保留 workflow 侧真差异：
+ * - parseWorkflowMeta：.js @pi-meta 块 → WorkflowEntry（m2 收敛改调 shared/meta-parser
+ *   parseResourceMeta，仅认 @pi-meta 新格式；description 截断用 core summarizeDescription
+ *   ——builtin 的 review-fix-loop 描述超长，全量注入每 turn 会膨胀 prompt）
+ * - includeTmp：发现覆盖 .pi/workflows/.tmp/（workflow-script generate 的产物）
+ * - C5①（convergence D-3）：formatWorkflowList/summarizeDescription/sortByCodepoint
+ *   下沉 core，本文件经 barrel 消费（渲染骨架与条目模板逐字节同 pi 旧本地实现——
+ *   CA2 快照验收前提）；guide 文案是 pi 宿主注入（core 不内嵌平台文案）
  */
 
 
 
-import type {
-	BeforeAgentStartEvent,
-	BeforeAgentStartEventResult,
-	ExtensionAPI,
-	ExtensionContext,
-	SessionShutdownEvent,
-	SessionStartEvent,
-} from "@earendil-works/pi-coding-agent";
-import { getLogger } from "@zhushanwen/pi-extension-logger";
-
-import { getHostServices } from "@zhushanwen/subagent-core/core/host-services.ts";
-
 import {
-	discoverResources,
-	findWorkspaceRoot,
-	getCachedParsed,
-} from "@zhushanwen/subagent-core/shared/resource-discovery.ts";
-import { parseResourceMeta } from "@zhushanwen/subagent-core/shared/meta-parser.ts";
-import { escapeXml, renderXmlSection } from "@zhushanwen/subagent-core/shared/xml-injection.ts";
-
-const logger = getLogger("injector");
-
-/**
- * Session 级 workflow 列表缓存（per-process = per-session），与 agentCache 对称。
- * 见 subagent-list-injector.ts 的 agentCache 注释。
- */
-let workflowCache: WorkflowEntry[] | null = null;
-
-/**
- * 注入块渲染缓存（与 workflowCache 同步更新）：before_agent_start 每个 turn 都要注入，
- * formatWorkflowList 在数据不变时输出完全相同——渲染一次随缓存复用。
- */
-let workflowInjectionCache: string | null = null;
-
-/** workflowCache 唯一写点：数据与渲染缓存同步更新（null 清空两者）。 */
-function setWorkflowCache(entries: WorkflowEntry[] | null): void {
-	workflowCache = entries;
-	workflowInjectionCache = entries !== null ? formatWorkflowList(entries) : null;
-}
-
-/** 注入段中单个 workflow 的最大描述长度（控制每 turn prompt 体积） */
-const MAX_DESC_LEN = 160;
+	formatWorkflowList,
+	parseResourceMeta,
+	summarizeDescription,
+	type WorkflowEntry,
+} from "@zhushanwen/subagent-core";
 
-/** 断句阈值比例：句末标点位置须 >= maxLen 的 40% 才采用，否则硬截断保留更多信息 */
-const DESC_BOUNDARY_MIN_RATIO = 0.4;
-
-/** 解析后的 workflow 条目（name + 截断后的 description + agentRef 路径） */
-export interface WorkflowEntry {
-	name: string;
-	description: string;
-	/** workflowRef：脚本 .js 文件的绝对路径（注入段 <location>，模型直接引用） */
-	path: string;
-}
+import { createResourceListInjector } from "./resource-list-injector.ts";
 
 /**
- * 将 workflow description 截断为 prompt 友好的摘要。
- * 优先在 limit 内的最后一个句末标点处断句；无合适断点则硬截断 + 省略号。
+ * pi 版注入引导文案（C5① guide 参数化——core 渲染函数不内嵌平台文案，宿主注入；
+ * 文案与改造前本地实现逐字一致——workflow 段 guide 无过期问题）。
+ *
+ * 引导语与具体 workflow 解耦：不写死内置名（列表本身已含全部 workflow，名字/描述
+ * 每 turn 由 @pi-meta 动态注入），只给通用路由指引 + read location 参数指针。
  */
-export function summarizeDescription(
-	desc: string,
-	maxLen = MAX_DESC_LEN,
-): string {
-	const trimmed = desc.trim();
-	if (trimmed.length <= maxLen) return trimmed;
-	const slice = trimmed.slice(0, maxLen);
-	const boundary = Math.max(
-		slice.lastIndexOf("。"),
-		slice.lastIndexOf("；"),
-		slice.lastIndexOf(";"),
-		slice.lastIndexOf(". "),
-	);
-	// 断点过靠前（< 阈值比例）时不采用，改硬截断保留更多信息
-	if (boundary > maxLen * DESC_BOUNDARY_MIN_RATIO) return slice.slice(0, boundary + 1);
-	return `${slice}…`;
-}
+export const WORKFLOW_LIST_GUIDE =
+	"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).";
 
 /**
  * 解析 workflow .js 文件的 meta（name + description），经 IF1 parseResourceMeta。
- *
- * 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 meta = parseResourceMeta(content, "workflow");
 	if (!meta || meta.kind !== "workflow") return null;
-	// path 由 discoverAllWorkflows 从 DiscoveredResource.path 填充
+	// path 由工厂 discover 从 DiscoveredResource.path 填充
 	return { name: meta.name, description: summarizeDescription(meta.description), path: "" };
 }
 
-/**
- * 用统一资源发现发现所有可用 workflow（includeTmp 覆盖 generate 产物）。
- * 解析经 getCachedParsed mtime 级缓存；输出按 name 码点序排序（KV-cache 契约，
- * 见 subagent-list-injector.ts discoverAllAgents 注释）。
- * 永不抛错——单文件读失败仅记日志。
- */
-export async function discoverAllWorkflows(
-	workspaceRoot: string,
-): Promise<WorkflowEntry[]> {
-	const resources = await discoverResources({
-		kind: "workflows",
-		workspaceRoot,
-		// 宿主注入根现取（pi 壳 discoveryRoots 每次现取 getAgentDir，实例隔离）；
-		// agentDir 形参已删——其唯一用途就是喂 ScanConfig（u0-data-discovery 偏差 #7）
-		hostRoots: getHostServices().discoveryRoots?.()?.workflows ?? [],
-		includeTmp: true,
-	});
-
-	const map = new Map<string, WorkflowEntry>();
-	for (const resource of resources) {
-		if (!resource.available) continue;
-		try {
-			const wf = getCachedParsed(resource.path, parseWorkflowMeta);
-			if (wf) map.set(wf.name, { ...wf, path: resource.path });
-		} catch (err) {
-			logger.error(
-				`[workflow-list-injector] skip unreadable workflow file ${resource.path}`,
-				{ reason: err instanceof Error ? err.message : String(err) },
-			);
-		}
-	}
-	return [...map.values()].sort((a, b) =>
-		a.name < b.name ? -1 : a.name > b.name ? 1 : 0,
-	);
-}
-
-/**
- * 将 workflow 列表格式化为 XML 注入段。
- *
- * 引导语对齐 subagent injector：workflow 已在下方列出，模型应直接 run；
- * list 仅用于查询运行态。builtin workflow 点名「run directly」。
- * 空列表返回空串（不注入）。
- */
-export function formatWorkflowList(workflows: WorkflowEntry[]): string {
-	if (workflows.length === 0) return "";
-
-	const items = workflows.map((wf) =>
-		`  <workflow><name>${escapeXml(wf.name)}</name><description>${escapeXml(wf.description)}</description><location>${escapeXml(wf.path)}</location></workflow>`,
-	);
-	return renderXmlSection({
-		tag: "available_workflows",
-		// 引导语与具体 workflow 解耦：不写死内置名（列表本身已含全部 workflow，
-		// 名字/描述每 turn 由 @pi-meta 动态注入），只给通用路由指引 + read location 参数指针。
-		guide: "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).",
-		items,
-	});
-}
-
-/**
- * 注册 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 {
-				setWorkflowCache(
-					await discoverAllWorkflows(
-						findWorkspaceRoot(ctx.cwd),
-					),
-				);
-			} 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),
-				});
-			}
-		},
-	);
+/** workflow 清单实例：缓存生命周期 / 发现 / 三 handler 全部经工厂骨架。 */
+const injector = createResourceListInjector<WorkflowEntry>({
+	kind: "workflows",
+	logTag: "[workflow-list-injector]",
+	parse: parseWorkflowMeta,
+	format: (workflows) => formatWorkflowList(workflows, { guide: WORKFLOW_LIST_GUIDE }),
+	includeTmp: true,
+});
 
-	pi.on(
-		"before_agent_start",
-		async (
-			event: BeforeAgentStartEvent,
-			ctx: ExtensionContext,
-		): Promise<BeforeAgentStartEventResult | void> => {
-			try {
-				// 读缓存；miss（session_start 未触发/缓存被清）则 fallback 重新发现+赋值
-				if (workflowCache === null) {
-					setWorkflowCache(
-						await discoverAllWorkflows(
-							findWorkspaceRoot(ctx.cwd),
-						),
-					);
-				}
-				// workflowInjectionCache 与 workflowCache 不变量同步（setWorkflowCache 保证），直接复用
-				const injection = workflowInjectionCache;
-				if (!injection) return;
-				return { systemPrompt: event.systemPrompt + injection };
-			} catch (err) {
-				logger.error("[workflow-list-injector] before_agent_start failed", {
-					reason: err instanceof Error ? err.message : String(err),
-				});
-			}
-		},
-	);
+/** 用统一资源发现发现所有可用 workflow（includeTmp 覆盖 generate 产物；骨架与排序契约见工厂）。 */
+export const discoverAllWorkflows = injector.discover;
 
-	pi.on(
-		"session_shutdown",
-		(_event: SessionShutdownEvent, _ctx: ExtensionContext): void => {
-			setWorkflowCache(null);
-		},
-	);
-}
+/** 注册 session 生命周期 handler，注入 `<available_workflows>` 段（与 subagent 注入 handler 链式）。 */
+export const setupWorkflowListInjector = injector.setup;

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

@@ -17,63 +17,73 @@ import { describe, expect, it } from "vitest";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { argKeysFromMeta, findFlattenedArgKeys } from "../tool-workflow";
-import { parseResourceMeta } from "@zhushanwen/subagent-core/shared/meta-parser.ts";
+// D9 下沉后权威实现迁至 core args-meta——宿主差异（TOOL_TOP_LEVEL 撞名保护）经
+// reservedKeys 注入，与 tool-workflow 调用点保持同一契约。
+import {
+  argKeysFromMeta,
+  findFlattenedArgKeys,
+} from "@zhushanwen/subagent-core/orchestration/args-meta.ts";
+import { TOOL_TOP_LEVEL } from "../tool-workflow";
+import { parseResourceMeta } from "@zhushanwen/subagent-core";
 
-// 真实参数集（argKeysFromMeta 产物——m6 动态数据源，与 TC2 同源防漂移）
-function rflKeys() {
+// 宿主 reservedKeys 注入（与 tool-workflow ARGS_META_OPTIONS 等值契约）
+const OPT = { reservedKeys: TOOL_TOP_LEVEL };
+
+// 真实参数 meta（@pi-meta parameters——m6 动态数据源，与 TC2 同源防漂移）
+function rflMeta() {
   const src = readFileSync(join(__dirname, "../../../node_modules/@zhushanwen/subagent-core/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);
+  return meta.parameters;
 }
-function chainKeys() {
+function chainMeta() {
   const src = readFileSync(join(__dirname, "../../../node_modules/@zhushanwen/subagent-core/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);
+  return meta.parameters;
 }
-const RFL = rflKeys();
-const CHAIN = chainKeys();
+const RFL = rflMeta();
+const CHAIN = chainMeta();
 
 describe("findFlattenedArgKeys (workflow args flatten detector — P0)", () => {
   it("TC3a: trigger——chain 参数集平铺 task 被识别；跨 workflow 区分（items 非 chain 参数不触发）", () => {
     expect(
-      findFlattenedArgKeys({ action: "run", name: "chain", task: "x" }, CHAIN.exact, CHAIN.patterns),
+      findFlattenedArgKeys({ action: "run", name: "chain", task: "x" }, CHAIN, OPT),
     ).toEqual(["task"]);
     // 跨 workflow：items 是 map-reduce 参数非 chain 参数 → 不触发（m6 动态集语义）
     expect(
-      findFlattenedArgKeys({ action: "run", name: "chain", items: ["a"] }, CHAIN.exact, CHAIN.patterns),
+      findFlattenedArgKeys({ action: "run", name: "chain", items: ["a"] }, CHAIN, OPT),
     ).toEqual([]);
   });
 
   it("TC3b: 嵌套 args 不触发", () => {
     expect(
-      findFlattenedArgKeys({ action: "run", name: "x", args: { task: "x", items: ["a"] } }, CHAIN.exact, CHAIN.patterns),
+      findFlattenedArgKeys({ action: "run", name: "x", args: { task: "x", items: ["a"] } }, CHAIN, OPT),
     ).toEqual([]);
   });
 
   it("TC3c: 顶层 + args 内共存不触发（args-排除保留）", () => {
     expect(
-      findFlattenedArgKeys({ action: "run", name: "x", args: { task: "x" }, task: "y" }, CHAIN.exact, CHAIN.patterns),
+      findFlattenedArgKeys({ action: "run", name: "x", args: { task: "x" }, task: "y" }, CHAIN, OPT),
     ).toEqual([]);
   });
 
   it("TC3d: 无已知键不触发；空集不触发", () => {
     expect(
-      findFlattenedArgKeys({ action: "run", name: "x", args: {} }, CHAIN.exact, CHAIN.patterns),
+      findFlattenedArgKeys({ action: "run", name: "x", args: {} }, CHAIN, OPT),
     ).toEqual([]);
+    // meta undefined → 空键集（原「空集不触发」等价形态）
     expect(
-      findFlattenedArgKeys({ action: "status" }, new Set(), []),
+      findFlattenedArgKeys({ action: "status" }, undefined),
     ).toEqual([]);
   });
 
   it("TC3e: review-fix-loop fixAgent 平铺被识别（动态集 exact）", () => {
     expect(
-      findFlattenedArgKeys({ action: "run", name: "review-fix-loop", fixAgent: "worker" }, RFL.exact, RFL.patterns),
+      findFlattenedArgKeys({ action: "run", name: "review-fix-loop", fixAgent: "worker" }, RFL, OPT),
     ).toEqual(["fixAgent"]);
     expect(
-      findFlattenedArgKeys({ action: "run", name: "review-fix-loop", args: { fixAgent: "worker" } }, RFL.exact, RFL.patterns),
+      findFlattenedArgKeys({ action: "run", name: "review-fix-loop", args: { fixAgent: "worker" } }, RFL, OPT),
     ).toEqual([]);
   });
 
@@ -81,27 +91,27 @@ describe("findFlattenedArgKeys (workflow args flatten detector — P0)", () => {
     expect(
       findFlattenedArgKeys(
         { action: "run", name: "review-fix-loop", targetType: "git-diff", target: "main" },
-        RFL.exact,
-        RFL.patterns,
+        RFL,
+        OPT,
       ),
     ).toEqual(["targetType", "target"]);
     expect(
       findFlattenedArgKeys(
         { action: "run", name: "review-fix-loop", batch1: "reviewer", autoCommit: true },
-        RFL.exact,
-        RFL.patterns,
+        RFL,
+        OPT,
       ),
     ).toEqual(["batch1", "autoCommit"]);
     expect(
       findFlattenedArgKeys(
         { action: "run", name: "review-fix-loop", args: { targetType: "git-diff", target: "main" } },
-        RFL.exact,
-        RFL.patterns,
+        RFL,
+        OPT,
       ),
     ).toEqual([]);
     // batchl 拼错（非数字后缀）不触发（m6 评审 C-1：pattern 自带数字后缀校验）
     expect(
-      findFlattenedArgKeys({ action: "run", name: "x", batchl: "reviewer" }, RFL.exact, RFL.patterns),
+      findFlattenedArgKeys({ action: "run", name: "x", batchl: "reviewer" }, RFL, OPT),
     ).toEqual([]);
   });
 
@@ -109,42 +119,43 @@ describe("findFlattenedArgKeys (workflow args flatten detector — P0)", () => {
     expect(
       findFlattenedArgKeys(
         { action: "run", name: "review-fix-loop", model: "ds-flash", maxFixAttempts: 3, convergeNewIssues: 2, convergeRounds: 3 },
-        RFL.exact,
-        RFL.patterns,
+        RFL,
+        OPT,
       ),
     ).toEqual(["maxFixAttempts", "convergeNewIssues", "convergeRounds"]);
     expect(
       findFlattenedArgKeys(
         { action: "run", name: "review-fix-loop", args: { model: "ds-flash", maxFixAttempts: 3 }, convergeRounds: 3 },
-        RFL.exact,
-        RFL.patterns,
+        RFL,
+        OPT,
       ),
     ).toEqual(["convergeRounds"]);
   });
 
   it("TC3h: non-object 输入返回 []", () => {
-    expect(findFlattenedArgKeys(null, new Set(), [])).toEqual([]);
-    expect(findFlattenedArgKeys(undefined, new Set(), [])).toEqual([]);
+    expect(findFlattenedArgKeys(null)).toEqual([]);
+    expect(findFlattenedArgKeys(undefined)).toEqual([]);
   });
 
   it("TC3i: tool 顶层键不误报（M-3 回归——合成 parameters 直测 argKeysFromMeta 排除）", () => {
     // 合成 parameters：workflow 声明参数 name（tool 键撞名）——argKeysFromMeta 必须排除
-    const keys = argKeysFromMeta({
+    const synthetic = {
       type: "object",
       properties: { name: { type: "string" }, task: { type: "string" } },
       required: ["name"],
-    });
+    };
+    const keys = argKeysFromMeta(synthetic, OPT);
     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,
+        synthetic,
+        OPT,
       ),
     ).toEqual([]);
     // 真实 meta 不含 name（探针实测 16 键）——附加验证
-    expect(RFL.exact.has("name")).toBe(false);
+    expect(argKeysFromMeta(RFL, OPT).exact.has("name")).toBe(false);
   });
 });

package/src/interface/__tests__/subagent-tool-path-guard.test.ts

@@ -12,39 +12,49 @@
 //   2. skillPath / cwd 相对路径 → 同步 reject
 //   3. 合法绝对路径放行 → 参数原样透传 service.execute（守卫零误伤对照）
 //
-// harness 复用 sdk-contract.test.ts 的 mock 链（pi-ai/typebox/subagent-service），
-// registerSubagentTool 后捕获 execute 回调直接调用。
+// harness（[u-5b / A-V3] 改写）：registerSubagentTool 后捕获 execute 回调直接调用。
+// SubagentService 经单例访问器槽注入 fake（setSubagentService，globalThis 槽——
+// executeSubagent 内 getSubagentService() 读同一槽，「守卫拒绝时 service.execute
+// 零触达」的承重断言不依赖整类 mock）；pi-ai/typebox 桩改共享桩
+// （src/__tests__/mocks/runtime-stubs.ts，async 工厂 + 动态 import，消费约定见
+// 桩 module 头注）。
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// 共享桩（./mocks/runtime-stubs.ts 相对本文件 = ../../__tests__/mocks/runtime-stubs.ts）：
+// vi.mock 工厂提升到文件顶部，体内不能引用普通顶层变量，一律经 async 工厂 +
+// 动态 import 取桩。
+vi.mock("@earendil-works/pi-ai", async () => {
+  const { piAiStringEnumStub } = await import("../../__tests__/mocks/runtime-stubs.ts");
+  return piAiStringEnumStub();
+});
+vi.mock("typebox", async () => {
+  const { typeboxStub } = await import("../../__tests__/mocks/runtime-stubs.ts");
+  return typeboxStub;
+});
 
-import { describe, expect, it, vi, beforeEach } from "vitest";
+import { setSubagentService } from "@zhushanwen/subagent-core";
 
-vi.mock("@earendil-works/pi-ai", () => ({
-  StringEnum: (values: string[]) => ({ type: "string", enum: values }),
-}));
-vi.mock("typebox", () => ({
-  Type: {
-    Object: (props: Record<string, unknown>) => ({ type: "object", properties: props }),
-    Optional: (schema: unknown) => ({ ...(schema as object), optional: true }),
-    String: (opts?: Record<string, unknown>) => ({ type: "string", ...opts }),
-    Boolean: () => ({ type: "boolean" }),
-    Number: (opts?: Record<string, unknown>) => ({ type: "number", ...opts }),
-    Array: (items: unknown) => ({ type: "array", items }),
-    Record: (key: unknown, value: unknown) => ({ type: "object", additionalProperties: value, key }),
-    Unknown: () => ({ type: "unknown" }),
-    Union: (members: unknown[]) => ({ type: "union", members }),
-    Literal: (value: unknown) => ({ type: "literal", value }),
-  },
-}));
+import { registerSubagentTool } from "../../interface/subagent-tool.ts";
+import { mockExtensionApi } from "@zhushanwen/subagent-core/testing/execution/__tests__/helpers/mock-extension-api.ts";
+
+// ── 访问器槽注入 helpers ─────────────────────────────────────
 
-// Mock getSubagentService：断言「守卫拒绝时 service.execute 零触达」的承重证据。
+/** fake service：execute 断言面（守卫拒绝 → 零触达）。 */
 const { mockServiceExecute } = vi.hoisted(() => ({
   mockServiceExecute: vi.fn(),
 }));
-vi.mock("@zhushanwen/subagent-core/execution/subagent-service.ts", () => ({
-  getSubagentService: () => ({ execute: mockServiceExecute }),
-}));
 
-import { registerSubagentTool } from "../../interface/subagent-tool.ts";
-import { mockExtensionApi } from "@zhushanwen/subagent-core/execution/__tests__/helpers/mock-extension-api.ts";
+/** 重置进程级 SubagentService 单例槽（setSubagentService 不接受 null，测试清理用
+ *  Symbol 直写；key 与生产 getServiceSlot 的 SERVICE_SLOT_KEY 一致）。 */
+function resetServiceSlot(): void {
+  const slot = Reflect.get(globalThis, Symbol.for("@zhushanwen/pi-subagents.service")) as
+    | { current: unknown }
+    | undefined;
+  if (slot) slot.current = null;
+}
+
+// ── harness ──────────────────────────────────────────────────
 
 type ExecuteCb = (...args: unknown[]) => Promise<unknown>;
 
@@ -82,9 +92,15 @@ describe("subagent tool 路径守卫（skillPath/cwd：绝对路径 + 禁 .. 穿
   beforeEach(() => {
     vi.clearAllMocks();
     mockServiceExecute.mockResolvedValue(stubHandle());
+    // 经真实单例访问器注入 fake service（executeSubagent 内 getSubagentService 读同槽）
+    setSubagentService({ execute: mockServiceExecute } as never);
     execute = captureExecute();
   });
 
+  afterEach(() => {
+    resetServiceSlot();
+  });
+
   // ── `..` 穿越段拒绝 ──
 
   it("skillPath 含 .. 穿越段 → immediate reject，service.execute 零触达", async () => {

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

@@ -12,6 +12,7 @@
 import { readFileSync } from "node:fs";
 import { dirname,join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
 
 import { describe, expect, it } from "vitest";
 
@@ -153,12 +154,22 @@ describe("subagent tool runtime handler — 错误文案含纠正正例", () =>
   // 让弱模型撞错后第二次能直接照抄正确形态。
   // 拍平后：startParam envelope 删除，平铺 task/slug 是合法形态；
   // 平铺检测 guard（hasFlattenedStartFields）已删除，源码不应再含此表达式。
-  it("subagent-actions.ts startHandler throw 含 Correct 纠正正例（平铺形态）", () => {
+  it("startHandler throw 含 Correct 纠正正例（平铺形态）", () => {
+    // [D6②] startHandler 内核（含 Correct 文案）已下沉 core subagent-actions-core，
+    // 断言目标跟随文案权威源。锚点用 ./workflows/* 子入口（exports 映射包根真实目录，
+    // 随源码走不依赖 dist 构建——relay-env 锚在 require 条件下落 dist/，CI 不构建
+    // workspace 包时 resolve 直接 MODULE_NOT_FOUND）。
+    const coreRoot = join(
+      dirname(
+        createRequire(import.meta.url).resolve("@zhushanwen/subagent-core/workflows/README.md"),
+      ),
+      "..",
+    );
     const actionsSrc = readFileSync(
-      join(__dirname, "../subagent-actions.ts"),
+      join(coreRoot, "src/execution/subagent-actions-core.ts"),
       "utf-8",
     );
-    // 三处 throw（input 缺失 / task 空白 / slug 空白）都应含 Correct 正例。
+    // 四处 throw（input 缺失 / task 空白 / slug 空白 / slug 超长）都应含 Correct 正例。
     // 用 occurrences 计数——至少 3 处。
     const occurrences = (actionsSrc.match(/Correct: \{"action":"start"/g) ?? []).length;
     expect(occurrences).toBeGreaterThanOrEqual(3);