@zhushanwen/subagent-core 0.6.0 → 0.7.0

package/src/execution/engine/engines/pi/__tests__/reader.test.ts

@@ -1,155 +0,0 @@
-// reader.test.ts —— PiEngine reader（P5）：readPiSessionView 对 session-reconstructor
-// 的投影包装。断言三件事：①合法 JSONL → SessionView（turns/toolCalls strip 内部态/
-// usage 聚合/source='native'）；②reconstructor 降级条件（文件缺失/缺 identity/无
-// assistant）→ undefined 不 throw；③不泄漏 InternalToolCall 内部态（_status/startedTs）。
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-import { beforeAll, describe, expect, it } from "vitest";
-
-import { readPiSessionView } from "../reader.ts";
-
-let tmpDir: string;
-
-beforeAll(() => {
-  tmpDir = fs.mkdtempSync(join(os.tmpdir(), "pi-reader-"));
-});
-
-// node:path 的 join 在 ESM 测试里直接用（避免顶部 import 与 beforeAll 顺序问题）
-function join(...segs: string[]): string {
-  return path.join(...segs);
-}
-
-/** 最小合法 subagent JSONL：header + identity + 一轮 assistant（text/thinking/toolCall）+ toolResult。 */
-function writeValidSession(file: string): void {
-  const lines = [
-    JSON.stringify({ type: "session", id: "pi-sess-1", cwd: "/proj", timestamp: "2026-08-25T10:00:00Z" }),
-    JSON.stringify({
-      type: "custom",
-      customType: "subagent-identity",
-      data: { id: "bg-1-abc", agent: "reviewer", mode: "background", task: "review code", slug: "rev", startedAt: 1756000000000 },
-    }),
-    JSON.stringify({
-      type: "message",
-      timestamp: "2026-08-25T10:00:01Z",
-      message: {
-        role: "assistant",
-        timestamp: 1756000001000,
-        content: [
-          { type: "thinking", thinking: "let me look" },
-          { type: "toolCall", id: "tc-1", name: "bash", arguments: { command: "ls" } },
-        ],
-        usage: { input: 10, output: 5, cacheRead: 1, cacheWrite: 2, cost: { total: 0.1 } },
-        stopReason: "toolUse",
-      },
-    }),
-    JSON.stringify({
-      type: "message",
-      timestamp: "2026-08-25T10:00:02Z",
-      message: { role: "toolResult", toolCallId: "tc-1", toolName: "bash", content: [{ type: "text", text: "file-a" }], timestamp: 1756000002000 },
-    }),
-    JSON.stringify({
-      type: "message",
-      timestamp: "2026-08-25T10:00:03Z",
-      message: {
-        role: "assistant",
-        timestamp: 1756000003000,
-        content: [{ type: "text", text: "all good" }],
-        usage: { input: 20, output: 8, cacheRead: 0, cacheWrite: 0, cost: { total: 0.05 } },
-        stopReason: "stop",
-      },
-    }),
-  ];
-  fs.writeFileSync(file, `${lines.join("\n")}\n`, "utf8");
-}
-
-describe("readPiSessionView", () => {
-  it("projects a valid subagent JSONL to a native SessionView", async () => {
-    const file = join(tmpDir, "valid.jsonl");
-    writeValidSession(file);
-
-    const view = await readPiSessionView(file);
-
-    expect(view).toBeDefined();
-    expect(view?.engineId).toBe("pi");
-    expect(view?.source).toBe("native");
-    // 两轮 assistant message → 两个 turn（toolResult 不产 turn）
-    expect(view?.turns).toHaveLength(2);
-
-    const [turn1, turn2] = view?.turns ?? [];
-    expect(turn1?.text).toBe("");
-    expect(turn1?.thinking).toBe("let me look");
-    expect(turn1?.toolCalls).toHaveLength(1);
-    const tc = turn1?.toolCalls[0];
-    expect(tc?.toolName).toBe("bash");
-    expect(tc?.args).toEqual({ command: "ls" });
-    expect(tc?.result).toEqual({ content: [{ type: "text", text: "file-a" }] });
-    // InternalToolCall 内部态不泄漏（导出纯净形状）
-    expect(tc).not.toHaveProperty("_status");
-    expect(tc).not.toHaveProperty("startedTs");
-    expect(turn1?.closed).toBe(true);
-
-    expect(turn2?.text).toBe("all good");
-    expect(turn2?.closed).toBe(true);
-
-    // usage 聚合：两轮 usageDelta 之和（cost 浮点累加有精度噪声，用 toBeCloseTo）
-    expect(view?.usage?.input).toBe(30)
-    expect(view?.usage?.output).toBe(13)
-    expect(view?.usage?.cacheRead).toBe(1)
-    expect(view?.usage?.cacheWrite).toBe(2)
-    expect(view?.usage?.cost).toBeCloseTo(0.15, 10)
-    expect(view?.usage?.total).toBe(46);
-  });
-
-  it("returns undefined (no throw) when file is missing", async () => {
-    await expect(readPiSessionView(join(tmpDir, "nope.jsonl"))).resolves.toBeUndefined();
-  });
-
-  it("returns undefined when identity entry is missing", async () => {
-    const file = join(tmpDir, "no-identity.jsonl");
-    fs.writeFileSync(
-      file,
-      `${JSON.stringify({ type: "session", id: "s" })}\n${JSON.stringify({
-        type: "message",
-        message: { role: "assistant", content: [{ type: "text", text: "hi" }], timestamp: 1 },
-      })}\n`,
-      "utf8",
-    );
-    await expect(readPiSessionView(file)).resolves.toBeUndefined();
-  });
-
-  it("returns undefined when no assistant message exists", async () => {
-    const file = join(tmpDir, "no-assistant.jsonl");
-    fs.writeFileSync(
-      file,
-      `${JSON.stringify({ type: "session", id: "s" })}\n${JSON.stringify({
-        type: "custom",
-        customType: "subagent-identity",
-        data: { id: "bg-2", agent: "w", mode: "background", task: "t", startedAt: 1 },
-      })}\n`,
-      "utf8",
-    );
-    await expect(readPiSessionView(file)).resolves.toBeUndefined();
-  });
-
-  it("omits usage when no message carries it", async () => {
-    const file = join(tmpDir, "no-usage.jsonl");
-    fs.writeFileSync(
-      file,
-      `${JSON.stringify({ type: "session", id: "s" })}\n${JSON.stringify({
-        type: "custom",
-        customType: "subagent-identity",
-        data: { id: "bg-3", agent: "w", mode: "background", task: "t", startedAt: 1 },
-      })}\n${JSON.stringify({
-        type: "message",
-        message: { role: "assistant", content: [{ type: "text", text: "hi" }], stopReason: "stop", timestamp: 1 },
-      })}\n`,
-      "utf8",
-    );
-    const view = await readPiSessionView(file);
-    expect(view?.turns).toHaveLength(1);
-    expect(view?.usage).toBeUndefined();
-  });
-});

package/src/execution/engine/engines/pi/__tests__/spawn-opts-direct.test.ts

@@ -1,257 +0,0 @@
-// src/execution/engine/engines/pi/__tests__/spawn-opts-direct.test.ts
-//
-// [D6 任务形状合流 / 实施期门⑤ ⛔ 硬门产物] pi 边界一次直出映射
-// （agentCallToExecuteOptions：AgentCallOpts → ExecuteOptions）的字段完整性对照表
-// 与逐字段断言。本文件取代已删除的两个往返保真测试：
-//   - execution/__tests__/execute-options-mapper.test.ts（mapToExecuteOptions，18 用例）
-//   - engines/pi/__tests__/task-spec-mapper.test.ts（spec 往返保真，12 用例）
-//
-// ════════════════════════════════════════════════════════════════════════
-// 字段完整性对照表（从两个被删 mapper 的现有测试提取字段全集，逐字段核对）
-// ════════════════════════════════════════════════════════════════════════
-//
-// 合流前链路（三形态两映射）：
-//   AgentCallOpts --mapToExecuteOptions--> ExecuteOptions
-//     --executeOptionsToTaskSpec--> AgentTaskSpec --taskSpecToExecuteOptions--> ExecuteOptions
-// 合流后（单一形状一次直出）：
-//   AgentCallOpts --agentCallToExecuteOptions--> ExecuteOptions
-//
-// ┌────────────────────┬──────────────────────────────────────┬────────────────────────────────────┬──────────────┐
-// │ ExecuteOptions 字段 │ 合流前（两级链的合成语义）             │ 合流后（一次直出）                   │ 断言用例      │
-// ├────────────────────┼──────────────────────────────────────┼────────────────────────────────────┼──────────────┤
-// │ task               │ prompt→opts.task→spec.task（恒等往返）│ prompt 直取                          │ D-01         │
-// │ slug               │ description??agent??"workflow-agent"  │ 同规则内联（截断 SLUG_MAX_LENGTH=35）│ D-02..D-05   │
-// │                    │ 截断（mapToExecuteOptions）            │                                      │              │
-// │ agent              │ spec.agent ?? persona.agentRef        │ agent 直取（agentRef 无写入方，裁撤） │ D-06         │
-// │ model              │ 透传（显式 override，不与 ctxModel 混）│ 同                                   │ D-07         │
-// │ thinkingLevel      │ spec.effort 恒等映射回                 │ thinkingLevel 直取（恒等层删除）      │ D-08         │
-// │ skillPath          │ persona.skillPath 收拢/还原（恒等）    │ skillPath 直取（平铺保留）           │ D-09         │
-// │ appendSystemPrompt │ persona.appendSystemPrompt 收拢/还原   │ appendSystemPrompt 直取              │ D-10         │
-// │ schema             │ 透传                                  │ 同                                   │ D-11         │
-// │ schemaEnv          │ spec.schema 派生优先（stringifyCached  │ schema 派生优先；无 schema 时         │ D-12..D-14   │
-// │                    │ compact，与 resolver 同函数同缓存）+   │ schemaEnv 兜底（原 ctx.schemaEnv      │              │
-// │                    │ ctx.schemaEnv 兜底（源 = opts.schemaEnv）│ 通道的合流等价）；均无 → undefined   │              │
-// │ maxTurns           │ 透传（预算语义：undefined = 不限）      │ 同                                   │ D-15         │
-// │ graceTurns         │ 透传（spec 字段）                      │ 同（合流形状可选字段）                │ D-16         │
-// │ ctxModel           │ RunContext.ctxModel 回填               │ 第 2 参直取（运行期件，不入声明）     │ D-17         │
-// │ fork               │ 透传                                  │ 同                                   │ D-18         │
-// │ worktree           │ 透传（boolean | WorktreeHandle 三态）  │ 同                                   │ D-19         │
-// │ cwd                │ 透传                                  │ 同                                   │ D-20         │
-// │ conversation       │ 透传（interact 控制面 task 标志）      │ 同                                   │ D-21         │
-// │ idleTimeoutMs      │ 透传（同上）                           │ 同                                   │ D-22         │
-// │ engine/engineFallback│ PiEngine.run 调用方追加（D9① 留痕）  │ 同（不在本函数，pi-engine.test 覆盖） │ pi-engine.test│
-// │ signal/onComplete  │ 不入 opts（port 设计删字段去向）       │ 同（RunContext/编排侧各归其位）       │ D-23         │
-// └────────────────────┴──────────────────────────────────────┴────────────────────────────────────┴──────────────┘
-//
-// 调用方扩展字段（引擎不消费，不入 spawn 参数）：scene / timeoutMs（SAR mergeTimeoutSignal
-// 合并进 signal）/ skill（resolver 解析为 skillPath）/ engine（SAR 路由层）/ returnMeta
-// （worker 层）——不入本映射即正确（D-24 断言不泄漏）。
-// 已裁撤字段（D6 登记于 AgentCallOpts 类型注释）：persona.agentRef、requires。
-//
-// 全字段直出快照断言（D-00）+ 逐字段用例双保险：快照锁全集、用例锁语义边界。
-
-import { describe, expect, it } from "vitest";
-
-import type { AgentCallOpts } from "../../../../../orchestration/models/types.ts";
-import { SLUG_MAX_LENGTH } from "../../../../../orchestration/models/types.ts";
-import type { ModelInfo } from "../../../../model-resolver.ts";
-import type { ExecuteOptions } from "../../../../types.ts";
-import { agentCallToExecuteOptions } from "../pi-engine.ts";
-
-/** 全字段样例（覆盖对照表全部直出映射点）。 */
-function makeFullCall(): AgentCallOpts {
-  return {
-    prompt: "review the diff",
-    description: "review-diff",
-    agent: "/agents/reviewer.md",
-    model: "zai-coding-cn/glm-5.2",
-    thinkingLevel: "high",
-    skillPath: "/skills/code-review/SKILL.md",
-    appendSystemPrompt: ["extra system prompt line"],
-    schema: { type: "object", properties: { verdict: { type: "string" } }, required: ["verdict"] },
-    maxTurns: 20,
-    graceTurns: 3,
-    fork: true,
-    worktree: true,
-    cwd: "/repo/worktree-x",
-    conversation: true,
-    idleTimeoutMs: 600_000,
-  };
-}
-
-describe("agentCallToExecuteOptions（D6 一次直出：AgentCallOpts → pi spawn 编排参数）", () => {
-  it("D-00 全字段直出快照（与合流前两级链的合成结果逐字段一致——原往返保真测试的直出等价物）", () => {
-    const result = agentCallToExecuteOptions(makeFullCall());
-    const expected: ExecuteOptions = {
-      task: "review the diff",
-      slug: "review-diff",
-      agent: "/agents/reviewer.md",
-      model: "zai-coding-cn/glm-5.2",
-      thinkingLevel: "high",
-      skillPath: "/skills/code-review/SKILL.md",
-      appendSystemPrompt: ["extra system prompt line"],
-      schema: { type: "object", properties: { verdict: { type: "string" } }, required: ["verdict"] },
-      schemaEnv: JSON.stringify({ type: "object", properties: { verdict: { type: "string" } }, required: ["verdict"] }),
-      maxTurns: 20,
-      graceTurns: 3,
-      ctxModel: undefined,
-      fork: true,
-      worktree: true,
-      cwd: "/repo/worktree-x",
-      conversation: true,
-      idleTimeoutMs: 600_000,
-    };
-    expect(result).toEqual(expected);
-  });
-
-  // ── task / slug（D-01..D-05）──
-
-  it("D-01 prompt → task", () => {
-    expect(agentCallToExecuteOptions({ prompt: "do the thing" }).task).toBe("do the thing");
-  });
-
-  it("D-02 description → slug", () => {
-    expect(agentCallToExecuteOptions({ prompt: "t", description: "fix-login" }).slug).toBe("fix-login");
-  });
-
-  it("D-03 description 缺失 → 回落 agent 名（保证 slug 非空）", () => {
-    expect(agentCallToExecuteOptions({ prompt: "t", agent: "worker" }).slug).toBe("worker");
-  });
-
-  it("D-04 description 与 agent 均缺失 → 回落 'workflow-agent'", () => {
-    expect(agentCallToExecuteOptions({ prompt: "t" }).slug).toBe("workflow-agent");
-  });
-
-  it("D-05 slug 截断：description > SLUG_MAX_LENGTH(35) 截到 35；= 35 不截（边界）", () => {
-    expect(agentCallToExecuteOptions({ prompt: "t", description: "a".repeat(36) }).slug).toBe("a".repeat(35));
-    expect(agentCallToExecuteOptions({ prompt: "t", description: "a".repeat(35) }).slug).toBe("a".repeat(35));
-    expect(SLUG_MAX_LENGTH).toBe(35);
-  });
-
-  // ── 身份 / 模型 / 推理档位（D-06..D-08）──
-
-  it("D-06 agent 直取（原 persona.agentRef 兜底随 PersonaSpec 裁撤——无生产写入方）", () => {
-    expect(agentCallToExecuteOptions({ prompt: "t", agent: "/a.md" }).agent).toBe("/a.md");
-    expect(agentCallToExecuteOptions({ prompt: "t" }).agent).toBeUndefined();
-  });
-
-  it("D-07 model：显式 override 透传；缺省 undefined（不与 ctxModel 混合）", () => {
-    const ctxModel: ModelInfo = { id: "ctx-model", name: "Ctx", provider: "test", reasoning: false };
-    expect(agentCallToExecuteOptions({ prompt: "t", model: "explicit-model" }, ctxModel).model).toBe("explicit-model");
-    expect(agentCallToExecuteOptions({ prompt: "t" }, ctxModel).model).toBeUndefined();
-  });
-
-  it("D-08 thinkingLevel 直取（原 effort 恒等映射层删除，含 7 档外的缺省）", () => {
-    for (const level of ["off", "low", "medium", "high", "max", undefined]) {
-      expect(agentCallToExecuteOptions({ prompt: "t", thinkingLevel: level }).thinkingLevel).toBe(level);
-    }
-  });
-
-  // ── persona 平铺字段（D-09..D-10）──
-
-  it("D-09 skillPath 直取（原 persona 收拢/还原恒等）", () => {
-    expect(agentCallToExecuteOptions({ prompt: "t", skillPath: "/s" }).skillPath).toBe("/s");
-    expect(agentCallToExecuteOptions({ prompt: "t" }).skillPath).toBeUndefined();
-  });
-
-  it("D-10 appendSystemPrompt 直取（含空数组归一语义：空数组保持空数组——下游 spread no-op 等价）", () => {
-    expect(agentCallToExecuteOptions({ prompt: "t", appendSystemPrompt: ["l1", "l2"] }).appendSystemPrompt).toEqual(["l1", "l2"]);
-    expect(agentCallToExecuteOptions({ prompt: "t", appendSystemPrompt: [] }).appendSystemPrompt).toEqual([]);
-    expect(agentCallToExecuteOptions({ prompt: "t" }).appendSystemPrompt).toBeUndefined();
-  });
-
-  // ── schema / schemaEnv（D-11..D-14）──
-
-  it("D-11 schema 透传为原始对象引用", () => {
-    const schema = { type: "object" };
-    expect(agentCallToExecuteOptions({ prompt: "t", schema }).schema).toBe(schema);
-  });
-
-  it("D-12 schemaEnv 派生：与 agent-opts-resolver 同函数（stringifySchemaCached compact），逐字节等值", () => {
-    const schema = { type: "object", properties: { a: { type: "number" } } };
-    expect(agentCallToExecuteOptions({ prompt: "t", schema }).schemaEnv).toBe(JSON.stringify(schema));
-  });
-
-  it("D-13 派生优先：schema 存在时 opts.schemaEnv（stale 值）被忽略", () => {
-    const schema = { type: "object" };
-    expect(agentCallToExecuteOptions({ prompt: "t", schema, schemaEnv: "STALE" }).schemaEnv).toBe(JSON.stringify(schema));
-  });
-
-  it("D-14 schemaEnv 兜底/缺省：无 schema 时用 opts.schemaEnv（解耦形态，原 ctx 兜底通道等价）；均无 → undefined（BC-6：childEnv 不注入）", () => {
-    expect(agentCallToExecuteOptions({ prompt: "t", schemaEnv: '{"type":"object"}' }).schemaEnv).toBe('{"type":"object"}');
-    expect(agentCallToExecuteOptions({ prompt: "t" }).schemaEnv).toBeUndefined();
-  });
-
-  // ── 轮数 / 运行期 / 隔离（D-15..D-20）──
-
-  it("D-15 maxTurns 透传（undefined = 不限，不挂 turns 估算 watchdog）", () => {
-    expect(agentCallToExecuteOptions({ prompt: "t", maxTurns: 20 }).maxTurns).toBe(20);
-    expect(agentCallToExecuteOptions({ prompt: "t" }).maxTurns).toBeUndefined();
-  });
-
-  it("D-16 graceTurns 透传（合流形状可选字段，chat 域经 host-task-spec 填充）", () => {
-    expect(agentCallToExecuteOptions({ prompt: "t", graceTurns: 3 }).graceTurns).toBe(3);
-    expect(agentCallToExecuteOptions({ prompt: "t" }).graceTurns).toBeUndefined();
-  });
-
-  it("D-17 ctxModel 从第 2 参回填（运行期件不入任务声明——D-008 兼底链路）", () => {
-    const ctxModel: ModelInfo = { id: "mimo-v2.5-pro", name: "MiMo", provider: "router-openai", reasoning: false };
-    expect(agentCallToExecuteOptions({ prompt: "t" }, ctxModel).ctxModel).toBe(ctxModel);
-    expect(agentCallToExecuteOptions({ prompt: "t" }).ctxModel).toBeUndefined();
-  });
-
-  it("D-18 fork 透传", () => {
-    expect(agentCallToExecuteOptions({ prompt: "t", fork: true }).fork).toBe(true);
-  });
-
-  it("D-19 worktree 三态（true/false/WorktreeHandle）直出保持", () => {
-    const handle = { path: "/wt", branch: "b", baseCommit: "c", mainCwd: "/repo" };
-    for (const wt of [true, false, handle] as const) {
-      expect(agentCallToExecuteOptions({ prompt: "t", worktree: wt }).worktree).toBe(wt);
-    }
-  });
-
-  it("D-20 cwd 透传", () => {
-    expect(agentCallToExecuteOptions({ prompt: "t", cwd: "/work" }).cwd).toBe("/work");
-  });
-
-  // ── 交互控制面（D-21..D-22）──
-
-  it("D-21 conversation 透传（interact 控制面的 task 标志）", () => {
-    expect(agentCallToExecuteOptions({ prompt: "t", conversation: true }).conversation).toBe(true);
-  });
-
-  it("D-22 idleTimeoutMs 透传", () => {
-    expect(agentCallToExecuteOptions({ prompt: "t", idleTimeoutMs: 12345 }).idleTimeoutMs).toBe(12345);
-  });
-
-  // ── 声明边界（D-23..D-24）──
-
-  it("D-23 运行期字段不入直出产物：signal/onComplete/engine/engineFallback 不由本函数产出（engine 由 run 调用方追加）", () => {
-    const result = agentCallToExecuteOptions(makeFullCall()) as unknown as Record<string, unknown>;
-    expect("signal" in result).toBe(false);
-    expect("onComplete" in result).toBe(false);
-    expect("engine" in result).toBe(false);
-    expect("engineFallback" in result).toBe(false);
-  });
-
-  it("D-24 调用方扩展字段不泄漏进 spawn 参数：scene/timeoutMs/skill/engine/returnMeta/denyTools/permissionMode", () => {
-    const result = agentCallToExecuteOptions({
-      prompt: "t",
-      scene: "coding",
-      timeoutMs: 5000,
-      skill: "code-review",
-      engine: "pi",
-      returnMeta: true,
-      denyTools: ["bash"],
-      permissionMode: "yolo",
-    }) as unknown as Record<string, unknown>;
-    expect("scene" in result).toBe(false);
-    expect("timeoutMs" in result).toBe(false);
-    expect("skill" in result).toBe(false);
-    expect("engine" in result).toBe(false);
-    expect("returnMeta" in result).toBe(false);
-    expect("denyTools" in result).toBe(false);
-    expect("permissionMode" in result).toBe(false);
-  });
-});

package/src/execution/engine/engines/pi/argv-mirror.ts

@@ -1,135 +0,0 @@
-/**
- * 从主进程 argv 解析可镜像给子进程的 flag。
- *
- * 独立模块：argv 解析是独立职责，从 session-runner.ts 拆出避免该文件超行数上限。
- */
-
-/**
- * 镜像 flag 集合：从主进程 argv 解析出的可透传给子进程的 flag。
- * 面向 buildSpawnArgs 的入参形态（解析后）。undefined 字段语义与解析为空一致。
- */
-export interface MirrorFlags {
-  noExtensions: boolean;
-  approve: boolean;
-  extensionPaths: string[];
-  noContextFiles: boolean;
-}
-
-/**
- * 有值 flag 的解析规则表：成员是「后跟一个值」的 flag 名（含长短形式）。
- * 用于 parseMirrorFlagArgs 跳过其他 flag 的值时不误吃。
- */
-const VALUED_FLAGS = new Set<string>([
-  "--extension", "-e",
-  "--skill",
-  "--model", "--system-prompt", "--append-system-prompt",
-  "--tools", "-t", "--exclude-tools", "-xt",
-  "--fork", "--session-dir", "--mode",
-  "--thinking", "--models",
-]);
-
-/** MirrorFlags 的布尔字段名（extensionPaths 数组字段单列，不进此表）。 */
-type MirrorBooleanKey = "noExtensions" | "approve" | "noContextFiles";
-
-/**
- * 布尔镜像 flag 表：token（长/短形式）→ MirrorFlags 布尔字段。
- * 用 Map 而非对象字面量查表——对象查表对 "__proto__"/"constructor" 等 token
- * 会命中原型链返回非 undefined，Map.get 无此陷阱。
- */
-const BOOLEAN_FLAGS = new Map<string, MirrorBooleanKey>([
-  ["--no-extensions", "noExtensions"],
-  ["-ne", "noExtensions"],
-  ["--approve", "approve"],
-  ["-a", "approve"],
-  ["--no-context-files", "noContextFiles"],
-  ["-nc", "noContextFiles"],
-]);
-
-/** argv 中 flag 的起始索引：argv[0]=runtime, argv[1]=binary 路径。 */
-const ARGV_FLAG_START = 2;
-
-/**
- * 从主进程 argv 解析可镜像的 flag（--no-extensions/--approve/--extension/--no-context-files）。
- *
- * 数据源是主 pi 进程的 process.argv：子进程 spawn 的父就是主进程，
- * 主进程 argv 完整保留启动时收到的全部 flag（已运行时验证）。这让子进程
- * extension/approve 加载行为与主进程一致，且对任意 pi 宿主通用（不止 xyz-agent）。
- *
- * 解析规则：
- * - --no-extensions / -ne、--approve / -a：布尔 flag（查 BOOLEAN_FLAGS 表）
- * - --no-context-files / -nc：布尔 flag（镜像理由：--extension 镜像会把
- *   @zhushanwen/pi-system-prompt 带进每个 subagent，该扩展靠子进程自己的
- *   argv 检测此 flag 决定是否注入全局 AGENTS.md——不镜像则用户 opt-out
- *   在 subagent 路径失效）
- * - --extension / -e：支持 `--extension <path>`（空格）与 `--extension=<path>`（等号）
- * - 其他 flag（在 VALUED_FLAGS 中）的值不被误当 extension 路径
- * - positional 参数被忽略
- * - argv[0]/argv[1] 是 bun/pi binary 路径，从 argv[2:] 开始扫
- */
-// [perf] 进程内 process.argv 引用恒定（唯一调用点 session-runner 每次 spawn 传同一引用），
-// 解析结果按 argv 引用相等 memo——每次 spawn 免重复扫描/正则。测试传新数组引用不命中。
-let memoArgv: readonly string[] | undefined;
-let memoResult: MirrorFlags | undefined;
-
-export function mirrorMainProcessFlags(argv: readonly string[]): MirrorFlags {
-  if (memoResult !== undefined && memoArgv === argv) return memoResult;
-  const result = parseMirrorFlagArgs(
-    argv.length > ARGV_FLAG_START ? argv.slice(ARGV_FLAG_START) : [],
-  );
-  memoArgv = argv;
-  memoResult = result;
-  return result;
-}
-
-/** 纯解析：扫描 flag 区段（argv[2:]）构造 MirrorFlags，不做 memo。 */
-function parseMirrorFlagArgs(flagArgs: readonly string[]): MirrorFlags {
-  const flags: Record<MirrorBooleanKey, boolean> = {
-    noExtensions: false,
-    approve: false,
-    noContextFiles: false,
-  };
-  const extensionPaths: string[] = [];
-
-  // argv[0]=runtime(bun), argv[1]=pi binary 路径；flag 从 argv[2] 起
-  for (let i = 0; i < flagArgs.length; i++) {
-    const tok = flagArgs[i];
-    const booleanKey = BOOLEAN_FLAGS.get(tok);
-    if (booleanKey !== undefined) {
-      flags[booleanKey] = true;
-      continue;
-    }
-    // 等号形式 --extension=path / -e=path
-    const eqMatch = /^(--extension|-e)=(.*)$/.exec(tok);
-    if (eqMatch) {
-      const val = eqMatch[2];
-      if (val) extensionPaths.push(val);
-      continue;
-    }
-    // 空格形式 --extension <path> / -e <path>：值在下一个 token
-    // [MF-7a] flag 判定收窄为 startsWith("--")：守卫原为 !startsWith("-")，把以单个
-    // - 开头的合法路径（如相对路径 -weird-dir/x.md）误判为 flag 跳过——extension 路径
-    // 静默丢失。pi CLI 的多字符长 flag 一律 -- 前缀，单 - 只接单字符短 flag（-e 本身），
-    // 故「-- 开头才算 flag」不误吃真 flag 且放行 - 开头路径。
-    if (tok === "--extension" || tok === "-e") {
-      const next = flagArgs[i + 1];
-      if (next !== undefined && !next.startsWith("--") && next.length > 0) {
-        extensionPaths.push(next);
-        i++; // 跳过值
-      }
-      continue;
-    }
-    // 其他有值 flag：跳过其值，避免误吃（如 --skill /a 的 /a）
-    if (VALUED_FLAGS.has(tok)) {
-      i++;
-      continue;
-    }
-    // 其他情况（未知 flag、--flag=val 形式、positional）忽略
-  }
-
-  return {
-    noExtensions: flags.noExtensions,
-    approve: flags.approve,
-    extensionPaths,
-    noContextFiles: flags.noContextFiles,
-  };
-}