@zhushanwen/pi-subagent-workflow 5.0.2 → 7.0.0

package/src/orchestration/__tests__/worker-script-builder-runtime.test.ts

@@ -111,6 +111,10 @@ interface RunOptions {
   timeoutMs?: number;
   /** workerData.callCache 预填（测缓存命中路径）。 */
   callCache?: Map<number, unknown>;
+  /** Run 级 model override（透传到 workerData.model → $MODEL global）。 */
+  model?: string;
+  /** Run 级 thinkingLevel override（透传到 workerData.thinkingLevel → $THINKING_LEVEL global）。 */
+  thinkingLevel?: string;
 }
 
 /**
@@ -132,6 +136,9 @@ function runWorker(userScript: string, opts: RunOptions = {}): Promise<RunResult
         callCache: opts.callCache instanceof Map
           ? Object.fromEntries(opts.callCache)
           : opts.callCache ?? {},
+        // Option B run-level override：透传到 $MODEL/$THINKING_LEVEL worker global
+        model: opts.model,
+        thinkingLevel: opts.thinkingLevel,
       },
     });
     // S8：创建后立即登记，afterEach 兜底清理（防止 promise 泄漏导致 Worker 未终止）
@@ -449,3 +456,65 @@ describe("buildWorkerScript runtime — W2 agent() returnMeta mode", () => {
   });
 });
 
+// ── P3/P4 runtime: run-level model/thinkingLevel override 真实注入（L0→L1 升级）──
+// worker-script-builder.test.ts 的 P3/P4 block 全是源码字符串断言（L0：验证「生成的
+// 源码含 $MODEL 注入行」）。本组起真实 Worker 线程，传 workerData.model/thinkingLevel，
+// 断言 agent() 三分支产出的 agent-call 消息 opts.model/opts.thinkingLevel 真实继承
+// $MODEL/$THINKING_LEVEL global（L1：验证「运行时 agent-call 携带正确 override」）。
+// 对应 docs/testing/ 断言价值层级 L1（真实 Worker 产物，非源码字符串）。
+
+describe("buildWorkerScript runtime — P3/P4 run-level model/thinkingLevel override 真实注入", () => {
+  it("workerData.model 经 $MODEL global 注入到 object 分支 agent() opts.model", async () => {
+    const script = `await agent({ prompt: "hi" }); return { done: true };`;
+    const res = await runWorker(script, { model: "anthropic/claude-sonnet-4-5" });
+    expect(res.agentCalls).toHaveLength(1);
+    expect(res.agentCalls[0]!.opts.model).toBe("anthropic/claude-sonnet-4-5");
+    expect(res.workerError).toBeUndefined();
+    expect(res.exitCode).not.toBe(1);
+  });
+
+  it("workerData.thinkingLevel 经 $THINKING_LEVEL global 注入到 opts.thinkingLevel", async () => {
+    const script = `await agent({ prompt: "hi" }); return { done: true };`;
+    const res = await runWorker(script, { thinkingLevel: "high" });
+    expect(res.agentCalls).toHaveLength(1);
+    expect(res.agentCalls[0]!.opts.thinkingLevel).toBe("high");
+    expect(res.workerError).toBeUndefined();
+  });
+
+  it("per-call model 优先于 $MODEL global（显式传 model 时不被 override 覆盖）", async () => {
+    const script = `await agent({ prompt: "hi", model: "openai/gpt-4o" }); return {};`;
+    const res = await runWorker(script, { model: "anthropic/claude-sonnet-4-5" });
+    expect(res.agentCalls).toHaveLength(1);
+    expect(res.agentCalls[0]!.opts.model).toBe("openai/gpt-4o");
+  });
+
+  it("agent() 三分支一致继承 $MODEL（string / task / object.prompt）", async () => {
+    const script = `
+      await agent("str-branch");
+      await agent({ task: "t" });
+      await agent({ prompt: "obj" });
+      return {};
+    `;
+    const res = await runWorker(script, {
+      model: "X/Y",
+      agentResults: [{}, {}, {}],
+    });
+    expect(res.agentCalls).toHaveLength(3);
+    expect(res.agentCalls.map((c) => c.opts.model)).toEqual(["X/Y", "X/Y", "X/Y"]);
+  });
+
+  it("model+thinkingLevel 同时注入（Option B 对称验证）", async () => {
+    const script = `await agent({ prompt: "hi" }); return {};`;
+    const res = await runWorker(script, { model: "p/m", thinkingLevel: "max" });
+    expect(res.agentCalls[0]!.opts.model).toBe("p/m");
+    expect(res.agentCalls[0]!.opts.thinkingLevel).toBe("max");
+  });
+
+  it("不传 model 时 opts.model 为 undefined（零配置默认继承主 agent，不误注入）", async () => {
+    const script = `await agent({ prompt: "hi" }); return {};`;
+    const res = await runWorker(script);
+    expect(res.agentCalls).toHaveLength(1);
+    expect(res.agentCalls[0]!.opts.model).toBeUndefined();
+  });
+});
+

package/src/orchestration/__tests__/worker-script-builder.test.ts

@@ -237,7 +237,7 @@ describe("buildWorkerScript — agent() thinkingLevel passthrough (3 branches)",
     const stringBranch = script.match(/typeof firstArg === "string"[\s\S]*?\};/);
     expect(stringBranch).toBeTruthy();
     expect(stringBranch![0]).toContain(
-      "thinkingLevel: (secondArg && typeof secondArg === \"object\" && secondArg.thinkingLevel) || undefined",
+      "thinkingLevel: (secondArg && typeof secondArg === \"object\" && secondArg.thinkingLevel) || $THINKING_LEVEL",
     );
   });
 
@@ -257,3 +257,53 @@ describe("buildWorkerScript — agent() thinkingLevel passthrough (3 branches)",
   });
 });
 
+// ── P3/P4: run-level model/thinkingLevel override global injection ──
+// Option B 对称单路径：workflow 顶层 model/thinkingLevel 经 workerData →
+// $MODEL/$THINKING_LEVEL worker global → agent() 三分支 fallback。
+// 验证生成的 worker 源码字符串包含 global 注入与三分支 fallback 逻辑。
+// 运行时真生效需 worker 集成 harness（设计文档 §6 降级为源码字符串断言）。
+
+describe("P3/P4 run-level model/thinkingLevel global injection + agent() fallback", () => {
+  const script = buildWorkerScript("// noop user script");
+
+  it("injects $MODEL global from workerData.model", () => {
+    expect(script).toContain('const $MODEL = (workerData.model && typeof workerData.model === "string") ? workerData.model : undefined;');
+  });
+
+  it("injects $THINKING_LEVEL global from workerData.thinkingLevel", () => {
+    expect(script).toContain('const $THINKING_LEVEL = (workerData.thinkingLevel && typeof workerData.thinkingLevel === "string") ? workerData.thinkingLevel : undefined;');
+  });
+
+  it("string branch falls back to $MODEL when secondArg.model omitted", () => {
+    const stringBranch = script.match(/typeof firstArg === "string"[\s\S]*?\};/);
+    expect(stringBranch).toBeTruthy();
+    expect(stringBranch![0]).toContain('secondArg.model) || $MODEL');
+  });
+
+  it("string branch falls back to $THINKING_LEVEL when secondArg.thinkingLevel omitted", () => {
+    const stringBranch = script.match(/typeof firstArg === "string"[\s\S]*?\};/);
+    expect(stringBranch).toBeTruthy();
+    expect(stringBranch![0]).toContain('secondArg.thinkingLevel) || $THINKING_LEVEL');
+  });
+
+  it("task/agent branch falls back to $MODEL when firstArg.model omitted", () => {
+    const taskAgentBranch = script.match(/firstArg\.task \|\| firstArg\.agent[\s\S]*?\};/);
+    expect(taskAgentBranch).toBeTruthy();
+    expect(taskAgentBranch![0]).toContain('model: firstArg.model || $MODEL');
+  });
+
+  it("task/agent branch falls back to $THINKING_LEVEL when firstArg.thinkingLevel omitted", () => {
+    const taskAgentBranch = script.match(/firstArg\.task \|\| firstArg\.agent[\s\S]*?\};/);
+    expect(taskAgentBranch).toBeTruthy();
+    expect(taskAgentBranch![0]).toContain('thinkingLevel: firstArg.thinkingLevel || $THINKING_LEVEL');
+  });
+
+  it("object branch injects $MODEL when opts.model omitted (guard fallback)", () => {
+    expect(script).toContain('if (!opts.model && $MODEL) opts.model = $MODEL;');
+  });
+
+  it("object branch injects $THINKING_LEVEL when opts.thinkingLevel omitted (guard fallback)", () => {
+    expect(script).toContain('if (!opts.thinkingLevel && $THINKING_LEVEL) opts.thinkingLevel = $THINKING_LEVEL;');
+  });
+});
+

package/src/orchestration/__tests__/workflow-nesting-e2e.test.ts

@@ -122,12 +122,12 @@ function makeDoneChildRun(opts: {
 function makeDeps(opts: {
   script?: WorkflowScript;
   childRun?: WorkflowRun;
-  registry?: { get: ReturnType<typeof vi.fn> };
+  registry?: { getPath: ReturnType<typeof vi.fn> };
 } = {}): LauncherDeps {
   const runs = new Map<string, WorkflowRun>();
   if (opts.childRun) runs.set(MOCK_RUN_ID, opts.childRun);
   const registry = opts.registry ?? {
-    get: vi.fn(async () => opts.script),
+    getPath: vi.fn(async () => opts.script),
   };
   return {
     registry,

package/src/orchestration/__tests__/workflows-e2e.test.ts

@@ -24,7 +24,7 @@
  *   内容 + 手动构造 WorkflowScript 对象，包装为一个满足 WorkflowScriptRegistry 接口
  *   的自定义 registry（loadWorkflowsFromDir）。
  */
-import { mkdtempSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -33,6 +33,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { JsonlRunStore } from "../jsonl-run-store.ts";
 import { type LauncherDeps,runAndWait } from "../launcher.ts";
+import { actionRun } from "../../interface/tool-workflow.ts";
 import type { LifecycleDeps } from "../models/ports.ts";
 import type { AgentRunner } from "../models/ports.ts";
 import type { AgentResult, AgentUsage } from "../models/types.ts";
@@ -41,6 +42,8 @@ import {
   WorkflowScript,
   type WorkflowSource,
 } from "../models/workflow-script.ts";
+import { parseResourceMeta } from "../../shared/meta-parser.ts";
+import { normalizeRef } from "../../shared/agent-ref.ts";
 import type { WorkflowScriptRegistry } from "../models/workflow-script-registry.ts";
 import { WorkerHostImpl } from "../worker-host.ts";
 
@@ -49,6 +52,10 @@ import { WorkerHostImpl } from "../worker-host.ts";
 // 即 __dirname → ..  (orchestration) → ..  (src) → ..  (subagent-workflow) → workflows
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const WORKFLOWS_DIR = join(__dirname, "..", "..", "..", "workflows");
+const AGENTS_DIR = join(__dirname, "..", "..", "..", "agents");
+// S2：workflowRef/agentRef = 绝对路径（注入段 <location> 同源）
+const wf = (name: string): string => join(WORKFLOWS_DIR, name + ".js");
+const agentMd = (name: string): string => join(AGENTS_DIR, name + ".md");
 
 // ── 临时 session 目录（RunStore 持久化根），每用例重建 ──────────────────
 let sessionDir: string;
@@ -147,25 +154,12 @@ function makeMockRunner(): AgentRunner & { run: ReturnType<typeof vi.fn> } {
  * 同语义，避免执行用户代码）。失败时回落到 name=文件名 stem 的空 meta。
  */
 function extractMeta(source: string, fallbackName: string): WorkflowMeta {
-  const metaPattern = /(?:export\s+)?const\s+meta\s*=\s*(\{[^]*?\});?\s*$/m;
-  const match = metaPattern.exec(source);
-  if (match) {
-    try {
-      const fn = new Function(`return (${match[1]});`);
-      const obj = fn();
-      if (obj && typeof obj === "object" && typeof obj.name === "string") {
-        return {
-          name: obj.name,
-          description: typeof obj.description === "string" ? obj.description : "",
-          phases: Array.isArray(obj.phases) ? obj.phases : [],
-        };
-      }
-    } catch (e) {
-      // meta 提取失败（非法 JS / regex 不匹配）→ 回落 fallback name，非测试关注点
-      void e;
-    }
-  }
-  return { name: fallbackName, description: "", phases: [] };
+  // m2 exec-review MINOR-1：旧 const meta regex + new Function 随 m2 迁移已失效（恒走空
+  // fallback，不再验证真实 meta 提取），改调 IF1 parseResourceMeta（与
+  // builtin-workflows-structure.test 一致）。失败时回落到 name=文件名 stem 的空 meta。
+  const meta = parseResourceMeta(source, "workflow");
+  if (meta && meta.kind === "workflow") return meta;
+  return { kind: "workflow", name: fallbackName, description: "", phases: [] };
 }
 
 /**
@@ -208,6 +202,29 @@ function loadWorkflowsFromDir(dir: string): Map<string, WorkflowScript> {
 function makeRegistry(scripts: Map<string, WorkflowScript>): WorkflowScriptRegistry {
   return {
     get: async (name: string) => scripts.get(name),
+    // S2：按路径加载（任意路径 .js，不限扫描目录）——路径未预扫则直接读文件
+    getPath: async (ref: string) => {
+      const normalized = normalizeRef(ref, ".js");
+      if (normalized === null) return undefined;
+      for (const script of scripts.values()) {
+        if (script.path === normalized) return script;
+      }
+      try {
+        const sourceCode = readFileSync(normalized, "utf-8");
+        const stem = basename(normalized, ".js");
+        const meta = extractMeta(sourceCode, stem);
+        return new WorkflowScript({
+          name: meta.name,
+          source: "saved",
+          path: normalized,
+          sourceCode,
+          meta,
+          available: true,
+        });
+      } catch {
+        return undefined;
+      }
+    },
     loadAll: async () => Array.from(scripts.values()),
     invalidate: () => {},
   };
@@ -292,7 +309,7 @@ describe("内置 workflow E2E（真实 worker thread + mock LLM runner）", () =
     async () => {
       const deps = makeDeps();
       const result = await runAndWait(
-        "parallel",
+        wf("parallel"),
         { target: "src/auth/login.ts" },
         deps,
         undefined,
@@ -315,7 +332,7 @@ describe("内置 workflow E2E（真实 worker thread + mock LLM runner）", () =
     async () => {
       const deps = makeDeps();
       const result = await runAndWait(
-        "chain",
+        wf("chain"),
         { task: "把这段需求文档拆成技术任务" },
         deps,
         undefined,
@@ -338,7 +355,7 @@ describe("内置 workflow E2E（真实 worker thread + mock LLM runner）", () =
     async () => {
       const deps = makeDeps();
       const result = await runAndWait(
-        "map-reduce",
+        wf("map-reduce"),
         { operation: "审查代码风格", items: ["file1.ts", "file2.ts"] },
         deps,
         undefined,
@@ -363,7 +380,7 @@ describe("内置 workflow E2E（真实 worker thread + mock LLM runner）", () =
     async () => {
       const deps = makeDeps();
       const result = await runAndWait(
-        "scatter-gather",
+        wf("scatter-gather"),
         { task: "重构认证模块，涉及 session/jwt/oauth 三块" },
         deps,
         undefined,
@@ -383,4 +400,140 @@ describe("内置 workflow E2E（真实 worker thread + mock LLM runner）", () =
     },
     RUN_TIMEOUT_MS,
   );
+
+  it(
+    "TC10: runAndWait 参数校验失败 → reason=invalid_args + runId='' + info 指引（chokepoint 先拦）",
+    async () => {
+      // review-fix-loop 有 parameters schema（唯一带 schema 的内置 workflow）——
+      // 缺 required targetType/target → chokepoint 在 worker 启动前拦截。
+      const deps = makeDeps();
+      const result = await runAndWait(
+        wf("review-fix-loop"),
+        { batch1: agentMd("code-reviewer") },
+        deps,
+        undefined,
+        RUN_TIMEOUT_MS,
+      );
+
+      expect(result.status).toBe("done");
+      expect(result.reason).toBe("invalid_args");
+      expect(result.runId).toBe("");
+      expect(result.error).toContain("Invalid args for workflow 'review-fix-loop'");
+      expect(result.error).toContain("targetType");
+      expect(result.error).toContain("Read the workflow script file");
+    },
+    RUN_TIMEOUT_MS,
+  );
+
+  it(
+    "TC12: coerce 结果到达 worker（chokepoint 原地 coerce → $ARGS 收到 boolean false）",
+    async () => {
+      // fixture 必须过 lint 入口检查（含 agent( 调用）+ typecheckMeta（name/description/phases）
+      const fixtureDir = mkdtempSync(join(tmpdir(), "wf-tc12-"));
+      try {
+        writeFileSync(
+          join(fixtureDir, "args-probe.js"),
+          [
+            "/* @pi-meta",
+            "name: args-probe",
+            "description: TC12 coerce probe fixture",
+            "phases: [a]",
+            "parameters:",
+            "  type: object",
+            "  properties:",
+            "    autoCommit: { type: boolean }",
+            "  required: [autoCommit]",
+            "*/",
+            'module.exports.execute = async ({ agent, $ARGS }) => {',
+            '  await agent({ prompt: "x" });',
+            "  return { t: typeof $ARGS.autoCommit, v: $ARGS.autoCommit };",
+            "};",
+            "",
+          ].join("\n"),
+          "utf-8",
+        );
+        const scripts = loadWorkflowsFromDir(fixtureDir);
+        const deps = { ...makeDeps(), registry: makeRegistry(scripts) };
+
+        const result = await runAndWait(
+          join(fixtureDir, "args-probe.js"),
+          { autoCommit: "false" },
+          deps,
+          undefined,
+          RUN_TIMEOUT_MS,
+        );
+
+        expect(result.reason).toBe("completed");
+        const outcome = result.scriptResult as { t: string; v: unknown };
+        expect(outcome.t).toBe("boolean");
+        expect(outcome.v).toBe(false);
+      } finally {
+        rmSync(fixtureDir, { recursive: true, force: true });
+      }
+    },
+    RUN_TIMEOUT_MS,
+  );
+
+  it("TC4: actionRun 顺序——not_found 优先（平铺 + 不存在名）；slug 护栏保留；chain 平铺 Correct 文案", async () => {
+    const deps = makeDeps();
+    // 平铺 + 不存在 name → not_found 优先（m6：registry.get 先于平铺检测）
+    const notFound = await actionRun(
+      { action: "run", name: wf("nope"), task: "x" },
+      deps,
+      undefined,
+    );
+    expect(notFound.isError).toBe(true);
+    expect(notFound.content![0]!.text).toContain("not found"); // DoD 用户可见断言
+    // R5（D7）：workflow not_found 文案含 <available_workflows> <location> 恢复指引
+    expect(notFound.content![0]!.text).toContain("<available_workflows>");
+    expect(notFound.content![0]!.text).toContain("<location>");
+    // chain 平铺 task → isError Correct 正例（动态集来自 registry）
+    const flat = await actionRun(
+      { action: "run", name: wf("chain"), task: "x" },
+      deps,
+      undefined,
+    );
+    expect(flat.isError).toBe(true);
+    expect(flat.content![0]!.text).toContain("Detected task at top level");
+    expect(flat.content![0]!.text).toContain("Correct:");
+    // slug 护栏保留（m6 顺序调整后仍在 runWorkflow 前）
+    const slug = await actionRun(
+      { action: "run", name: wf("chain"), args: { task: "x" }, slug: "a".repeat(40) },
+      deps,
+      undefined,
+    );
+    expect(slug.isError).toBe(true);
+    expect(slug.content![0]!.text).toContain("slug exceeds");
+  });
+
+  it("TC6: 跨 workflow 平铺语义——review-fix-loop 平铺 task（非其参数）走 args-validator", async () => {
+    const deps = makeDeps();
+    // task 是 chain 参数非 review-fix-loop 参数 → 不报平铺 → args 缺 targetType
+    // → m3 chokepoint invalid_args（错误更准——评审 m-5 语义锁定）
+    const result = await actionRun(
+      { action: "run", name: wf("review-fix-loop"), task: "x" },
+      deps,
+      undefined,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content![0]!.text).toContain("Invalid args for workflow 'review-fix-loop'");
+    expect(result.content![0]!.text).toContain("targetType");
+  });
+
+  it("TC9: actionRun 参数校验失败 → isError ToolResult + §5.3 指引", async () => {
+    const deps = makeDeps();
+    const result = await actionRun(
+      { action: "run", name: wf("review-fix-loop"), args: { batch1: agentMd("code-reviewer") } },
+      deps,
+      undefined,
+    );
+
+    expect(result.isError).toBe(true);
+    const text = result.content?.[0]?.text ?? "";
+    expect(text).toContain("Invalid args for workflow 'review-fix-loop'");
+    expect(text).toContain("targetType");
+    expect(text).toContain("Read the workflow script file");
+  });
+
+
 });

package/src/orchestration/agent-opts-resolver.ts

@@ -1,83 +1,48 @@
 /**
- * Agent options resolver — resolves agent name / skill / schema to system
- * prompt files + env vars on every dispatch (BL-1).
+ * Agent options resolver — resolves skill / schema to append-system-prompt
+ * content + env vars on every dispatch (BL-1).
  *
- * BL-1：解析 workflow 脚本里 `agent({agent,skill,schema})` 的 inline override，
- * 否则 pi 子进程只收到原始 prompt，没有 --append-system-prompt / --skill /
- * PI_WORKFLOW_SCHEMA。AgentCallOpts 从 engine/models/types 引入。
+ * BL-1：解析 workflow 脚本里 `agent({skill,schema})` 的 inline override，
+ * 否则 pi 子进程只收到原始 prompt，没有 --append-system-prompt /
+ * --skill / PI_WORKFLOW_SCHEMA。
+ *
+ * 职责范围（M2 修正）：仅处理 schema SO 指令（内容直传 appendSystemPrompt）+ skill。
+ * agent ref 处理（systemPrompt/model/thinkingLevel）已移交 resolveIdentity（execution 层，
+ * 经 getAgentConfig + resolveModel 完整覆盖），消除双重注入与 model 层级混乱。
  *
  * 调用方：engine/error-recovery.ts dispatchAgentCall（每次 agent-call 消息）。
- * - agent → AgentRegistry.resolve → systemPrompt 写临时文件 → systemPromptFiles（--append-system-prompt）
  * - skill → resolveSkillPath → skillPath（--skill）
- * - schema → 结构化输出指令写临时文件 → systemPromptFiles + schemaEnv（PI_WORKFLOW_SCHEMA）
+ * - schema → 结构化输出指令内容直传 appendSystemPrompt（--append-system-prompt）+ schemaEnv（PI_WORKFLOW_SCHEMA）
  *
- * 临时文件在 activeTempFiles 集合注册，session_shutdown 时由 cleanupAllTempFiles 统一回收。
+ * M2 bug 修正：旧实现把 schema 指令写成临时文件、push 文件路径（而非内容）给下游，
+ * 下游 mapper/session-runner 把路径当文本拼进最终 append 文件，导致 schema 指令从未
+ * 进入子进程。改为指令内容直传（不写盘、无临时文件）。
  */
 
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-
 import type { AgentCallOpts } from "./models/types.ts";
-import type { AgentRegistry } from "../execution/agent-registry.ts";  // type-only（本文件不 new，只接收实例参数）
 import { resolveSkillPath } from "./skill-discovery.ts";
 
-const UUID_SLICE_LEN = 8;
-
 export interface ResolveResult {
   opts: AgentCallOpts;
   error?: string;
 }
 
 /**
- * Resolve agent name and schema into systemPromptFiles + skillPath + schemaEnv.
+ * Resolve skill and schema into appendSystemPrompt (content array) + skillPath + schemaEnv.
  *
- * - Agent systemPrompt -> temp file via --append-system-prompt
  * - Skill name -> resolved SKILL.md dir path via --skill
- * - Schema JSON -> temp file with structured-output instruction + PI_WORKFLOW_SCHEMA env
+ * - Schema JSON -> structured-output instruction string pushed into appendSystemPrompt
+ *   (content, not file path) + PI_WORKFLOW_SCHEMA env
+ *
+ * Agent ref is intentionally NOT handled here — resolveIdentity (execution layer)
+ * covers it via getAgentConfig + resolveModel. Handling agent here would cause
+ * double-injection (agentConfig.systemPrompt at session-runner + appendSystemPrompt)
+ * and model-tier confusion.
  *
- * Returns the enriched opts and any temp files created (registered in activeTempFiles).
- * Caller is responsible for cleaning up files via cleanupAllTempFiles (session-scoped).
+ * Returns the enriched opts.
  */
-export function resolveAgentOpts(
-  opts: AgentCallOpts,
-  agentRegistry: AgentRegistry,
-  sessionDir: string,
-  activeTempFiles: Set<string>,
-): ResolveResult {
-  const systemPromptFiles: string[] = [];
-
- // Resolve agent system prompt
-  if (opts.agent) {
-    const discovered = agentRegistry.get(opts.agent);  // 新 API: get() 替代 resolve()，返回 AgentConfig（含 systemPrompt+model）
-    if (!discovered) {
-      const available = agentRegistry.list().join(", ");
-      return { opts, error: `Agent not found: ${opts.agent}. Available: ${available || "(none)"}` };
-    }
-
-    const hasSystemPrompt = discovered.systemPrompt.trim().length > 0;
-    if (hasSystemPrompt) {
-      try {
-        const tmpDir = path.join(sessionDir, "workflow-tmp");
-        fs.mkdirSync(tmpDir, { recursive: true });
-        const tmpFile = path.join(tmpDir, `agent-prompt-${randomUUID()}.md`);
-        fs.writeFileSync(tmpFile, discovered.systemPrompt, "utf-8");
-        activeTempFiles.add(tmpFile);
-        systemPromptFiles.push(tmpFile);
-      } catch (err: unknown) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return { opts, error: `Temp file write error: ${msg}` };
-      }
-    }
-
-    // M3: 用 === undefined 而非 ||，避免空串被当 falsy 替换成 frontmatter model
-    opts = {
-      ...opts,
-      model: opts.model === undefined ? discovered.model : opts.model,
-      // M2: 传播 agent .md frontmatter 的 thinkingLevel（之前 AgentCallOpts 无此字段导致丢失）
-      thinkingLevel: opts.thinkingLevel ?? discovered.thinkingLevel,
-    };
-  }
+export function resolveAgentOpts(opts: AgentCallOpts): ResolveResult {
+  const appendSystemPrompt: string[] = [];
 
  // Resolve skill name to SKILL.md path
   if (opts.skill) {
@@ -88,53 +53,38 @@ export function resolveAgentOpts(
     opts = { ...opts, skillPath };
   }
 
- // Inject schema as structured-output instruction via --append-system-prompt
- // and set environment variable for conditional tool + hook activation.
+ // Inject schema as structured-output instruction into appendSystemPrompt (content,
+ // not temp file) and set environment variable for conditional tool + hook activation.
+ // M2 fix: previously wrote the instruction to a temp file and pushed the FILE PATH,
+ // which got concatenated into the final append file as path garbage — the SO instruction
+ // never reached the subprocess. Now the instruction content is pushed directly.
   if (opts.schema) {
-    try {
-      const tmpDir = path.join(sessionDir, "workflow-tmp");
-      fs.mkdirSync(tmpDir, { recursive: true });
-      const tmpFile = path.join(tmpDir, `so-${randomUUID().slice(0, UUID_SLICE_LEN)}.txt`);
-      const schemaJson = JSON.stringify(opts.schema);
-      const content = [
-        "## MANDATORY: Structured Output Requirement",
-        "",
-        "This task requires structured output.",
-        "Your FINAL action must be calling the `structured-output` tool.",
-        "",
-        "The schema is enforced by the system (PI_WORKFLOW_SCHEMA). You only pass `data` — do NOT pass a `schema` parameter.",
-        `Your \`data\` must conform to this schema:`,
-        "```json",
-        schemaJson,
-        "```",
-        "",
-        "Rules:",
-        "- Call structured-output with ONLY the `data` parameter. The system validates it against the schema above automatically.",
-        "- Do NOT output JSON in your text response — use the structured-output tool.",
-        "- Do NOT skip this step. The structured-output call IS your result.",
-        "- Complete all other work FIRST, then call structured-output as the last action.",
-      ].join("\n");
-      fs.writeFileSync(tmpFile, content, "utf-8");
-      activeTempFiles.add(tmpFile);
-      systemPromptFiles.push(tmpFile);
+    const schemaJson = JSON.stringify(opts.schema);
+    const content = [
+      "## MANDATORY: Structured Output Requirement",
+      "",
+      "This task requires structured output.",
+      "Your FINAL action must be calling the `structured-output` tool.",
+      "",
+      "The schema is enforced by the system (PI_WORKFLOW_SCHEMA). You only pass `data` — do NOT pass a `schema` parameter.",
+      `Your \`data\` must conform to this schema:`,
+      "```json",
+      schemaJson,
+      "```",
+      "",
+      "Rules:",
+      "- Call structured-output with ONLY the `data` parameter. The system validates it against the schema above automatically.",
+      "- Do NOT output JSON in your text response — use the structured-output tool.",
+      "- Do NOT skip this step. The structured-output call IS your result.",
+      "- Complete all other work FIRST, then call structured-output as the last action.",
+    ].join("\n");
+    appendSystemPrompt.push(content);
 
  // Set env var for structured-output extension to activate tool + hook
-      opts = { ...opts, schemaEnv: schemaJson };
-    } catch (err: unknown) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { opts, error: `Schema temp file write error: ${msg}` };
-    }
+    opts = { ...opts, schemaEnv: schemaJson };
   }
 
   return {
-    opts: { ...opts, ...(systemPromptFiles.length > 0 ? { systemPromptFiles } : {}) },
+    opts: { ...opts, ...(appendSystemPrompt.length > 0 ? { appendSystemPrompt } : {}) },
   };
 }
-
-/** Remove all remaining active temp files (called from session_shutdown). */
-export function cleanupAllTempFiles(activeTempFiles: Set<string>): void {
-  for (const fp of activeTempFiles) {
-    try { fs.unlinkSync(fp); } catch { /* already deleted */ void undefined; }
-  }
-  activeTempFiles.clear();
-}