@zhushanwen/subagent-core 0.8.0 → 0.9.0

package/src/execution/__tests__/stream-sink-retirement.test.ts

@@ -88,9 +88,12 @@ vi.mock("../alive-store.ts", async (importOriginal) => {
   };
 });
 
-vi.mock("../finalized-marker.ts", () => ({
-  writeFinalized: vi.fn(),
-  readFinalized: vi.fn(() => false),
+vi.mock("../state-marker.ts", () => ({
+  writeFinalizedState: vi.fn(),
+  writeCancelledState: vi.fn(),
+  readStateMarker: vi.fn(() => undefined),
+  statStateStamp: vi.fn(() => null),
+  STATE_SIDECAR_EXT: ".state",
 }));
 
 vi.mock("../manifest-store.ts", () => {
@@ -98,7 +101,7 @@ vi.mock("../manifest-store.ts", () => {
     writeManifest = vi.fn(async () => {});
     readManifest = vi.fn(async () => null);
     listAllSync = vi.fn(() => []);
-    recoverTmpFiles = vi.fn(async () => []);
+    sweepTmpFiles = vi.fn(async () => 0);
   }
   return { ManifestStore: vi.fn(function (_recordsDir: string) { return new FakeManifestStore(); }) };
 });
@@ -107,7 +110,7 @@ import { spawn } from "node:child_process";
 
 import { ModelConfigService } from "../model-config-service.ts";
 import type { ModelInfo, ModelRegistryLike } from "../model-resolver.ts";
-import { RELAY_ENV_NODE, RELAY_ENV_SCRIPT, RELAY_ENV_SOCKET } from "../relay-env.ts";
+import { RELAY_ENV_NODE, RELAY_ENV_SCRIPT, RELAY_ENV_SOCKET } from "@zhushanwen/subagent-engine-sdk";
 import { SubagentService } from "../subagent-service.ts";
 import { createBackgroundStream } from "../stream-sink.ts";
 import type { ExtensionMode } from "../host-mode.ts";

package/src/execution/__tests__/subagent-actions-core.test.ts

@@ -18,7 +18,10 @@
 // 读 Date.now()——本文件用 fake timers 固定时钟（now = 探针首跑实值 1788189209000），
 // 使快照期望值与实测值逐字可比。
 
-import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 
 import {
   BG_MESSAGE,
@@ -38,6 +41,7 @@ import {
   wrapForkFromPrompt,
 } from "../subagent-actions-core.ts";
 import { ResurrectDeniedError } from "../types.ts";
+import { writeAliveMarker } from "../alive-store.ts";
 import type {
   ExecutionHandle,
   ExecutionRecord,
@@ -49,6 +53,11 @@ import type { SubagentService } from "../subagent-service.ts";
 // ── 时钟固定（duration 快照确定性，见文件头）──
 const FROZEN_NOW = 1788189209000;
 
+/** [U1/A4] 「异进程且存活」的确定性模拟 pid：1 号进程（launchd/init）必然存在且非
+ *  本测试进程——kill(1, 0) 对普通用户返回 EPERM，isProcessAlive 按「存在但无权限」
+ *  保守判活（self-pid 排除后不能再以本进程 pid 模拟异进程实例，同 cold-lookup.test.ts）。 */
+const FOREIGN_LIVE_PID = 1;
+
 beforeAll(() => {
   vi.useFakeTimers({ now: FROZEN_NOW });
 });
@@ -144,6 +153,9 @@ function makeService(over: Record<string, unknown> = {}): SubagentService {
     getRecordForAction: vi.fn(),
     closeSubagent: vi.fn(),
     deliverChatMessage: vi.fn(),
+    // [H1 U2 / D5 双写点①] messageHandler 升级 gate 判据读 service.canUpgradeToConversation
+    //（stub 缺省放行 = pi 默认引擎语义；gate 拒绝面专项见 conversation-continuation.test.ts）。
+    canUpgradeToConversation: vi.fn(() => true),
     // [U2] startHandler 缺省 collect 解析读真实 config（偏差#3 接线）：stub 缺省 async
     //（本文件不测 collect 语义，专项见 start-collect-guard.test.ts）。
     getCollectSyncDefault: vi.fn(() => "async" as const),
@@ -152,6 +164,9 @@ function makeService(over: Record<string, unknown> = {}): SubagentService {
   return {
     execute: m.execute,
     cancel: m.cancel,
+    // [H1 U2 / D5 双写点①] messageHandler 升级 gate 判据经平铺访问器（真实 service 为
+    // 平铺方法，非 queries/chatActions 聚合面成员），stub 须同构挂载。
+    canUpgradeToConversation: m.canUpgradeToConversation,
     // [U2 偏差#3 接线] startHandler 经平铺访问器读 config 缺省 collect（真实 service
     // 为平铺方法 subagent-service.ts:1786，非 queries 聚合面成员），stub 须同构挂载。
     getCollectSyncDefault: m.getCollectSyncDefault,
@@ -433,7 +448,7 @@ describe("⛔4 listHandler（limit 夹紧 + 过滤 + enrich，快照 = pi-sw 实
         ],
       },
     });
-    expect(collectRecords).toHaveBeenCalledWith(20, "all");
+    expect(collectRecords).toHaveBeenCalledWith(20, "all", false);
     // light record（getFullRecord undefined）回退原样投影
     expect(getFullRecord).toHaveBeenCalledWith("bg-2");
   });
@@ -441,17 +456,17 @@ describe("⛔4 listHandler（limit 夹紧 + 过滤 + enrich，快照 = pi-sw 实
   it("缺省 → collectRecords(20,'running')", () => {
     const collectRecords = vi.fn(() => [] as SubagentRecord[]);
     listHandler(makeService({ collectRecords }), undefined);
-    expect(collectRecords).toHaveBeenCalledWith(20, "running");
+    expect(collectRecords).toHaveBeenCalledWith(20, "running", false);
   });
 
   it("limit 夹紧：500 → 100 上限；0 → 1 下限（非默认值）", () => {
     const high = vi.fn(() => [] as SubagentRecord[]);
     listHandler(makeService({ collectRecords: high }), { includeFinished: true, limit: 500 });
-    expect(high).toHaveBeenCalledWith(100, "all");
+    expect(high).toHaveBeenCalledWith(100, "all", false);
 
     const low = vi.fn(() => [] as SubagentRecord[]);
     listHandler(makeService({ collectRecords: low }), { includeFinished: true, limit: 0 });
-    expect(low).toHaveBeenCalledWith(1, "all");
+    expect(low).toHaveBeenCalledWith(1, "all", false);
 
     expect(DEFAULT_LIST_LIMIT).toBe(20);
     expect(MAX_LIST_LIMIT).toBe(100);
@@ -473,7 +488,7 @@ describe("⛔4 cancelHandler（守卫 + 归属判定 + CAS 失败映射，快照
     expect(await errOf(() => cancelHandler(makeService(), { subagentId: "bg-x" }))).toEqual({
       errorName: "Error",
       message:
-        'No subagent record with id "bg-x". It may have finished — use action:\'list\' with includeFinished:true to verify.',
+        'No subagent record with id "bg-x". It may have finished — use action:\'list\' with includeFinished:true to verify (add includeWorkflow:true to also see workflow-dispatched subagents).',
     });
   });
 
@@ -505,7 +520,7 @@ describe("⛔4 cancelHandler（守卫 + 归属判定 + CAS 失败映射，快照
     ).toEqual({
       errorName: "Error",
       message:
-        'No subagent record with id "bg-9". It may have finished — use action:\'list\' with includeFinished:true to verify.',
+        'No subagent record with id "bg-9". It may have finished — use action:\'list\' with includeFinished:true to verify (add includeWorkflow:true to also see workflow-dispatched subagents).',
     });
   });
 
@@ -613,7 +628,7 @@ describe("⛔4 messageHandler（守卫 + upgrade + 投递，快照 = pi-sw 实
     });
   });
 
-  it("chatMode record → deliverChatMessage(text trim + interrupt) + 领域对象", async () => {
+  it("chatMode record → deliverChatMessage(text trim) + 领域对象（[H1 U6] interrupt 退役）", async () => {
     const deliverChatMessage = vi.fn(async () => {});
     const chatRecord = makeExecRecord({ id: "bg-1", chatMode: true, slug: "src-slug" });
     const r = await messageHandler(
@@ -626,7 +641,7 @@ describe("⛔4 messageHandler（守卫 + upgrade + 投递，快照 = pi-sw 实
       slug: "src-slug",
       response: { delivered: true },
     });
-    expect(deliverChatMessage).toHaveBeenCalledWith(chatRecord, "go on", true);
+    expect(deliverChatMessage).toHaveBeenCalledWith(chatRecord, "go on");
   });
 
   it("one-shot upgrade：非 chatMode running record 收 message → 置位 chatMode 后投递", async () => {
@@ -637,7 +652,27 @@ describe("⛔4 messageHandler（守卫 + upgrade + 投递，快照 = pi-sw 实
       { subagentId: "bg-1", text: "hi" },
     );
     expect(upgradeRec.chatMode).toBe(true);
-    expect(deliverChatMessage).toHaveBeenCalledWith(upgradeRec, "hi", false);
+    expect(deliverChatMessage).toHaveBeenCalledWith(upgradeRec, "hi");
+  });
+
+  it("[H1 U2 / D5 双写点①] one-shot upgrade gate 拒绝：unsupported 引擎（canUpgradeToConversation=false）→ 硬拒 + fork/重派指引，chatMode 不置位", async () => {
+    const deliverChatMessage = vi.fn(async () => {});
+    const zcodeRec = makeExecRecord({ id: "bg-z", chatMode: false, status: "running", engine: "zcode" });
+    const err = await errOf(() =>
+      messageHandler(
+        makeService({
+          getRecordForAction: vi.fn(() => zcodeRec),
+          deliverChatMessage,
+          canUpgradeToConversation: vi.fn(() => false),
+        }),
+        { subagentId: "bg-z", text: "hi" },
+      ),
+    );
+    // 文案 = engineConversationUpgradeUnsupportedError 单源（错误码前缀 + 拒绝依据）
+    expect(err.errorName).toBe("EngineError");
+    expect(err.message).toContain("cannot be upgraded to a resumable conversation");
+    expect(zcodeRec.chatMode).toBe(false);
+    expect(deliverChatMessage).not.toHaveBeenCalled();
   });
 
   it("getRecordForAction 拒绝 + 无终态快照 → 原错误透传（文案最准原则）", async () => {
@@ -694,14 +729,14 @@ describe("⛔4 messageHandler（守卫 + upgrade + 投递，快照 = pi-sw 实
       message:
         "subagent bg-1 was deliberately closed by user (closedReason: user-close) — " +
         "it cannot be messaged or resumed; nothing can reattach to it. " +
-        "Recovery: start a new subagent (action:'start'); use action:'list' with includeFinished:true to review its final output.",
+        "Recovery: start a new subagent (action:'start'); use action:'list' with includeFinished:true to review its final output (add includeWorkflow:true to also see workflow-dispatched subagents).",
     });
     expect(await errOf(() => messageHandler(mkSvc("cancelled"), { subagentId: "bg-1", text: "hi" }))).toEqual({
       errorName: "Error",
       message:
         "subagent bg-1 was deliberately closed by user (closedReason: cancelled) — " +
         "it cannot be messaged or resumed; nothing can reattach to it. " +
-        "Recovery: start a new subagent (action:'start'); use action:'list' with includeFinished:true to review its final output.",
+        "Recovery: start a new subagent (action:'start'); use action:'list' with includeFinished:true to review its final output (add includeWorkflow:true to also see workflow-dispatched subagents).",
     });
   });
 
@@ -800,6 +835,16 @@ describe("⛔4 closeHandler（force 语义透传，快照 = pi-sw 实测）", ()
 // forkFromHandler（守卫链 1–6）
 // ============================================================
 describe("⛔4 forkFromHandler（守卫链 + slug 派生 + prompt 包装，快照 = pi-sw 实测）", () => {
+  // [U4b/E2] 双宿主探针 fixture 目录：守卫 3 现查探针读真实 .alive 侧车（不再读
+  // rec.externalInstance 缓存字段），用临时目录落盘驱动，自建自删。
+  let forkDir: string;
+  beforeEach(() => {
+    forkDir = fs.mkdtempSync(path.join(os.tmpdir(), "actions-core-fork-"));
+  });
+  afterEach(() => {
+    fs.rmSync(forkDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  });
+
   function makeForkService(source: SubagentRecord | undefined, execute = vi.fn(async (_opts: { task: string; slug?: string; agent?: string }): Promise<ExecutionHandle> => ({
     mode: "background",
     subagentId: "bg-new-1",
@@ -838,15 +883,21 @@ describe("⛔4 forkFromHandler（守卫链 + slug 派生 + prompt 包装，快
       errorName: "Error",
       message:
         'No subagent record with id "bg-404". It may never have existed or been garbage-collected — ' +
-        "use action:'list' with includeFinished:true to verify the id.",
+        "use action:'list' with includeFinished:true to verify the id (add includeWorkflow:true to also see workflow-dispatched subagents).",
     });
   });
 
-  it("守卫 3：externalInstance 活 pid marker → another-process 文案", async () => {
+  it("守卫 3：异进程活实例（.alive 恒活外部 pid）→ another-process 文案（双宿主形态）", async () => {
+    // [U4b/E2] 双宿主形态：宿主 A 持有中的 record（.alive = A 进程的活 pid 声明）被
+    // 宿主 B 冷查重建，B fork-from 该源时守卫 3 现查探针命中 → 拒绝（源仍在异进程
+    // 运行，接续会读到半截历史）。[U1/A4] self-pid 排除后「异进程」不能用本测试进程
+    // pid 模拟，改恒活外部 pid 1（launchd/init：kill(1,0) → EPERM → isProcessAlive 判活）。
+    const sessionFile = path.join(forkDir, "sess-foreign.jsonl");
+    writeAliveMarker(sessionFile, { pid: FOREIGN_LIVE_PID, id: "bg-1", startedAt: 5 });
     expect(
       await errOf(() =>
         forkFromHandler(
-          makeForkService(makeRec({ id: "bg-1", externalInstance: { pid: 4321, id: "p-1", startedAt: 5 } })),
+          makeForkService(makeRec({ id: "bg-1", status: "running", sessionFile })),
           { sourceSubagentId: "bg-1" },
         ),
       ),
@@ -885,7 +936,7 @@ describe("⛔4 forkFromHandler（守卫链 + slug 派生 + prompt 包装，快
         message:
           `subagent bg-1 was deliberately closed by user (closedReason: ${closedReason}) — ` +
           "deliberately-closed records cannot be resumed or branched from; nothing can reattach to them. " +
-          "Recovery: start a fresh subagent (action:'start'); use action:'list' with includeFinished:true to review its final output.",
+          "Recovery: start a fresh subagent (action:'start'); use action:'list' with includeFinished:true to review its final output (add includeWorkflow:true to also see workflow-dispatched subagents).",
       });
     }
   });

package/src/execution/__tests__/subagent-service-multiproc-guard.test.ts

@@ -29,7 +29,6 @@ vi.mock("../alive-store.ts", () => ({
   removeAliveMarker: vi.fn(),
   readAliveMarker: vi.fn(() => undefined),
   isProcessAlive: vi.fn(() => false),
-  ALIVE_SOFT_TIMEOUT_MS: 3_600_000,
   findForeignLiveInstance: foreignLiveSpy,
 }));
 

package/src/execution/__tests__/subagent-service-notify-gate.test.ts

@@ -90,7 +90,7 @@ describe("T4① notify gate closedReason whitelist", () => {
   });
 
   it("kickOffChatRound 应答回注不注入 parent-new closed records（notify 门白名单）", async () => {
-    const { agentDir, service, pi } = setup();
+    const { agentDir, service, store, pi } = setup();
     clearEngines();
     const fake = registerFakePiEngine();
     const record = createRecord("sa-gate-new", {
@@ -103,19 +103,28 @@ describe("T4① notify gate closedReason whitelist", () => {
       rootSessionId: "root-session",
       controller: new AbortController(),
     });
-    // 模拟 disposeAllRecords 先行编排性关闭后，迟到的 kickOffChatRound 应答回注
+    // 模拟 disposeAllRecords 先行编排性关闭后，迟到的 kickOffChatRound 应答回注。
+    // [H4/U5 适配] 终态形态对齐生产：disposeAllRecords 走 markFinalized（status
+    // closed + endedAt + archive）——只设 closedReason 不设 status 会让 settle 路径
+    // tryTransition(running→closed) 抢成赢家覆写 user-close，门判据随之漂移；record
+    // 补 register 进 store 对齐「store 外 record 无编排性关闭可达」的生产形态。
+    record.status = "closed";
+    record.endedAt = Date.now();
     record.closedReason = "parent-new";
+    store.register(record);
     // [W3] 轮次编排入口 kickOffChatRound（私有，bracket 调用先例）——协议 run 发起后
     // 挂起，编排性关闭先行，再模拟引擎应答（迟到回注被门拦）。
-    const kickOffChatRound = (
-      service as unknown as Record<string, (...args: unknown[]) => void>
-    )["kickOffChatRound"];
+    // [R4 深绑改写] kickOffChatRound 本体已迁 RunOrchestration 聚合——bracket 路径
+    // 改经聚合实例（断言对象与强度不变；this 绑定 = 聚合实例，即方法真实宿主）。
+    const orchestration = (
+      service as unknown as { runOrchestration: { kickOffChatRound: (...args: unknown[]) => void } }
+    ).runOrchestration;
     const identity = {
       agent: "general-purpose",
       agentConfig: undefined,
       resolved: { model: { id: "model", name: "Model", provider: "test", reasoning: false }, thinkingLevel: undefined },
     };
-    kickOffChatRound.call(service, record, { task: "t", slug: "gate" }, identity, undefined, 1000);
+    orchestration.kickOffChatRound(record, { task: "t", slug: "gate" }, identity, undefined, 1000);
     await vi.waitFor(() => expect(fake.runs.length).toBe(1));
     fake.runs[0]!.settle({ content: "late round text" });
     await Promise.resolve();
@@ -127,7 +136,7 @@ describe("T4① notify gate closedReason whitelist", () => {
   });
 
   it("kickOffChatRound 应答回注对真实失败关闭（gc）仍通知", async () => {
-    const { agentDir, service, pi } = setup();
+    const { agentDir, service, store, pi } = setup();
     clearEngines();
     const fake = registerFakePiEngine();
     const record = createRecord("sa-gate-gc", {
@@ -140,16 +149,23 @@ describe("T4① notify gate closedReason whitelist", () => {
       rootSessionId: "root-session",
       controller: new AbortController(),
     });
+    // 同上 [H4/U5 适配]：失败终态化（closed/gc/endedAt）+ register 进 store 的完整
+    // 生产形态——迟到回注按 CAS 输家路径走，门判据读真实 gc 关闭原因。
+    record.status = "closed";
+    record.endedAt = Date.now();
     record.closedReason = "gc";
-    const kickOffChatRound = (
-      service as unknown as Record<string, (...args: unknown[]) => void>
-    )["kickOffChatRound"];
+    store.register(record);
+    // [R4 深绑改写] kickOffChatRound 本体已迁 RunOrchestration 聚合——bracket 路径
+    // 改经聚合实例（断言对象与强度不变；this 绑定 = 聚合实例，即方法真实宿主）。
+    const orchestration = (
+      service as unknown as { runOrchestration: { kickOffChatRound: (...args: unknown[]) => void } }
+    ).runOrchestration;
     const identity = {
       agent: "general-purpose",
       agentConfig: undefined,
       resolved: { model: { id: "model", name: "Model", provider: "test", reasoning: false }, thinkingLevel: undefined },
     };
-    kickOffChatRound.call(service, record, { task: "t", slug: "gate" }, identity, undefined, 1000);
+    orchestration.kickOffChatRound(record, { task: "t", slug: "gate" }, identity, undefined, 1000);
     await vi.waitFor(() => expect(fake.runs.length).toBe(1));
     fake.runs[0]!.settle({ content: "round" });
     await vi.waitFor(() => expect(pi.sendMessage).toHaveBeenCalled());

package/src/execution/__tests__/subagent-service-parent-guard.test.ts

@@ -53,11 +53,16 @@ function makePi(): PiLike {
 }
 
 /** 暴露私有字段供测试注入身份。[D3-⑤] 基线住进 execNesting（公共层
- * ExecutionNestingContext），注入经 setBaseline 测试面。 */
+ *  ExecutionNestingContext），注入经 setBaseline 测试面。
+ *  [R1 深绑改写·清单③ SI 形态] sessionRootId/execNesting 随域 #2 聚合迁入
+ *  SessionBaselines——ServiceInternals 重定义为壳 baselines 聚合路径（store 仍为壳
+ *  #1 留壳字段，路径不变）；断言对象与强度不变，路径对齐终态结构。 */
 interface ServiceInternals {
   store: RecordStore;
-  sessionRootId: string | null;
-  execNesting: { setBaseline(state: { recordId: string | undefined; depth: number } | null): void };
+  baselines: {
+    sessionRootId: string | null;
+    execNesting: { setBaseline(state: { recordId: string | undefined; depth: number } | null): void };
+  };
 }
 
 /** 构造一个 chatMode idle record（message/close action 的典型目标态）。 */
@@ -97,7 +102,8 @@ describe("[v4 A-5 / P7] getRecordForAction 直接父校验", () => {
     service.initSession({ pi: makePi(), sessionId: "root-session" });
     internals = service as unknown as ServiceInternals;
     store = internals.store;
-    sessionRootId = internals.sessionRootId!;
+    // [R1 深绑改写] sessionRootId 经 baselines 聚合路径读取（原 internals.sessionRootId）。
+    sessionRootId = internals.baselines.sessionRootId!;
   });
 
   afterEach(() => {
@@ -110,7 +116,7 @@ describe("[v4 A-5 / P7] getRecordForAction 直接父校验", () => {
   it("身份=sa-A（直接父）→ 放行操作孙级 record B（parentRecordId=sa-A）", () => {
     const recordB = makeRecord("sa-B", sessionRootId, { parentRecordId: "sa-A", depth: 2, status: "running" });
     store.register(recordB);
-    internals.execNesting.setBaseline(PARENT_A);
+    internals.baselines.execNesting.setBaseline(PARENT_A);
 
     expect(service.chatActions.getRecordForAction("sa-B")).toBe(recordB);
   });
@@ -120,7 +126,7 @@ describe("[v4 A-5 / P7] getRecordForAction 直接父校验", () => {
   it("身份=undefined（主进程）拒绝孙级 record B，错误含 'direct parent' + 'parent=sa-A'", () => {
     const recordB = makeRecord("sa-B", sessionRootId, { parentRecordId: "sa-A", depth: 2, status: "running" });
     store.register(recordB);
-    internals.execNesting.setBaseline(MAIN_PROCESS);
+    internals.baselines.execNesting.setBaseline(MAIN_PROCESS);
 
     expect(() => service.chatActions.getRecordForAction("sa-B")).toThrow(/direct parent/);
     expect(() => service.chatActions.getRecordForAction("sa-B")).toThrow(/see \/subagents list, parent=sa-A/);
@@ -129,7 +135,7 @@ describe("[v4 A-5 / P7] getRecordForAction 直接父校验", () => {
   it("身份=undefined（主进程）放行顶层 record（parentRecordId=undefined 视为根层）", () => {
     const topRecord = makeRecord("sa-top", sessionRootId, { parentRecordId: undefined, depth: 0, status: "running" });
     store.register(topRecord);
-    internals.execNesting.setBaseline(MAIN_PROCESS);
+    internals.baselines.execNesting.setBaseline(MAIN_PROCESS);
 
     expect(service.chatActions.getRecordForAction("sa-top")).toBe(topRecord);
   });
@@ -139,7 +145,7 @@ describe("[v4 A-5 / P7] getRecordForAction 直接父校验", () => {
   it("身份=sa-B（兄弟进程）拒绝孙级 record B（parentRecordId=sa-A ≠ baseline sa-B）", () => {
     const recordB = makeRecord("sa-B", sessionRootId, { parentRecordId: "sa-A", depth: 2, status: "running" });
     store.register(recordB);
-    internals.execNesting.setBaseline(SIBLING_B);
+    internals.baselines.execNesting.setBaseline(SIBLING_B);
 
     expect(() => service.chatActions.getRecordForAction("sa-B")).toThrow(/direct parent/);
     expect(() => service.chatActions.getRecordForAction("sa-B")).toThrow(/see \/subagents list, parent=sa-A/);
@@ -150,7 +156,7 @@ describe("[v4 A-5 / P7] getRecordForAction 直接父校验", () => {
   it("子进程（baseline=sa-A）拒绝顶层 record（身份缺省视为根层，仅主进程可操作）", () => {
     const topRecord = makeRecord("sa-top", sessionRootId, { parentRecordId: undefined, depth: 0, status: "running" });
     store.register(topRecord);
-    internals.execNesting.setBaseline(PARENT_A);
+    internals.baselines.execNesting.setBaseline(PARENT_A);
 
     expect(() => service.chatActions.getRecordForAction("sa-top")).toThrow(/direct parent/);
   });
@@ -158,7 +164,7 @@ describe("[v4 A-5 / P7] getRecordForAction 直接父校验", () => {
   it("P7 场景：主进程拒绝曾孙 record C（parentRecordId=sa-B），错误含 baseline=root + parent=sa-B", () => {
     const recordC = makeRecord("sa-C", sessionRootId, { parentRecordId: "sa-B", depth: 3, status: "running" });
     store.register(recordC);
-    internals.execNesting.setBaseline(MAIN_PROCESS);
+    internals.baselines.execNesting.setBaseline(MAIN_PROCESS);
 
     const fn = () => service.chatActions.getRecordForAction("sa-C");
     expect(fn).toThrow(/direct parent/);
@@ -170,7 +176,7 @@ describe("[v4 A-5 / P7] getRecordForAction 直接父校验", () => {
     // 跨 session 树的 record：rootSessionId 不匹配 → 走首个 throw（not found or not owned）
     const foreignRecord = makeRecord("sa-foreign", "other-session", { parentRecordId: "sa-A", depth: 2, status: "running" });
     store.register(foreignRecord);
-    internals.execNesting.setBaseline(PARENT_A);
+    internals.baselines.execNesting.setBaseline(PARENT_A);
 
     expect(() => service.chatActions.getRecordForAction("sa-foreign")).toThrow(/not found or not owned/);
   });