@zhushanwen/subagent-core 0.2.0 → 0.4.0

package/src/execution/__tests__/lifecycle-manager.test.ts

@@ -9,6 +9,15 @@
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
+// [LC-7/T7①] Mock 共享 logger：env 非法值回落默认的 warn 留痕可被断言
+//（对齐 channel-registry-handshake.test.ts 模式；vi.mock 自动 hoist 到 import 前）。
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("../../core/logger.ts", () => ({
+  getLogger: () => loggerMock,
+}));
+
 import {
   DEFAULT_IDLE_TIMEOUT_MS,
   DEFAULT_MAX_ALIVE_PROCESSES,
@@ -30,6 +39,9 @@ describe("lifecycle-manager — V2 §5.2 模块 1", () => {
   beforeEach(() => {
     vi.useFakeTimers();
     _resetLifecycleState();
+    loggerMock.debug.mockClear();
+    loggerMock.warn.mockClear();
+    loggerMock.error.mockClear();
     // [F-4 同源修复] env 隔离：「默认超时」用例依赖 XYZ_SUBAGENT_IDLE_TIMEOUT_MS
     // 未设基线（getEnvIdleTimeoutMs 会覆盖 DEFAULT），宿主 export 即假红。空串 = 未设。
     vi.stubEnv("XYZ_SUBAGENT_IDLE_TIMEOUT_MS", "");
@@ -138,6 +150,33 @@ describe("lifecycle-manager — V2 §5.2 模块 1", () => {
       expect(() => armIdleTimer("sa-env-overflow", onTimeout)).toThrowError(/2147483647/);
       expect(hasIdleTimer("sa-env-overflow")).toBe(false);
     });
+
+    // [LC-7/T7①] env 非法值回落默认不再静默：warn 留痕（env 名 + 实际值 + 生效行为）。
+    // 「以为设了极长保活、实际回落 5min」的语义漂移必须可诊断。
+    it("[LC-7] env 非法值（'30m' 非纯数字）→ 回落 DEFAULT_IDLE_TIMEOUT_MS 且 warn 留痕", () => {
+      vi.stubEnv("XYZ_SUBAGENT_IDLE_TIMEOUT_MS", "30m");
+      const onTimeout = vi.fn();
+      armIdleTimer("sa-lc7-invalid", onTimeout); // 不传 timeoutMs → env（非法）→ DEFAULT
+
+      // 生效行为 = 默认 5min（非法值没有按字面 '30m' 也不按禁用处理）
+      vi.advanceTimersByTime(DEFAULT_IDLE_TIMEOUT_MS - 1);
+      expect(onTimeout).not.toHaveBeenCalled();
+      vi.advanceTimersByTime(1);
+      expect(onTimeout).toHaveBeenCalledTimes(1);
+
+      expect(loggerMock.warn).toHaveBeenCalledTimes(1);
+      const msg = String(loggerMock.warn.mock.calls[0]?.[0] ?? "");
+      expect(msg).toContain("XYZ_SUBAGENT_IDLE_TIMEOUT_MS"); // env 变量名
+      expect(msg).toContain("30m"); // 实际值
+      expect(msg).toContain("DEFAULT_IDLE_TIMEOUT_MS"); // 生效行为：回落默认
+    });
+
+    it("[LC-7] env 未设（空串基线）→ 静默走 DEFAULT，零 warn（未配置不是异常）", () => {
+      const onTimeout = vi.fn();
+      armIdleTimer("sa-lc7-clean", onTimeout);
+      expect(hasIdleTimer("sa-lc7-clean")).toBe(true);
+      expect(loggerMock.warn).not.toHaveBeenCalled();
+    });
   });
 
   // ============================================================

package/src/execution/__tests__/manifest-store-tmp-recovery.test.ts

@@ -0,0 +1,99 @@
+// src/execution/__tests__/manifest-store-tmp-recovery.test.ts
+//
+// [u-svc / T5④ / PS-13] recoverTmpFiles 循环内 per-file 容错：
+// 单个 tmp 文件操作失败（ENOENT——并发回收/外部清理抢先）只 warn + 跳过，
+// 不再中断整轮——剩余 tmp 继续处理；返回值形态不变（跳过者不计数）。
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
+
+// fs partial mock：unlinkSync 可按路径注错，其余转发真实实现。
+const { unlinkSyncMock } = vi.hoisted(() => ({ unlinkSyncMock: vi.fn() }));
+vi.mock("node:fs", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("node:fs")>();
+  return {
+    ...actual,
+    unlinkSync: unlinkSyncMock,
+    default: { ...actual, unlinkSync: unlinkSyncMock },
+  };
+});
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { ManifestStore } from "../manifest-store.ts";
+
+const VALID_MANIFEST = {
+  id: "sa-good",
+  rootSessionId: "root-1",
+  agentName: "general-purpose",
+  createdAt: 1,
+  status: "running",
+};
+
+describe("T5④ recoverTmpFiles per-file tolerance", () => {
+  let dir: string;
+  let store: ManifestStore;
+
+  beforeEach(async () => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "manifest-tmp-recovery-"));
+    store = new ManifestStore(dir);
+    // 真实 unlinkSync（mock 模块对象上的 unlinkSync 已被替换，不能自引用转发）
+    const actualFs = await vi.importActual<typeof import("node:fs")>("node:fs");
+    unlinkSyncMock.mockReset();
+    unlinkSyncMock.mockImplementation((p: fs.PathLike) => actualFs.unlinkSync(p));
+    loggerMock.warn.mockClear();
+    loggerMock.error.mockClear();
+    loggerMock.debug.mockClear();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("processes remaining tmp files when one unlink fails mid-loop", async () => {
+    const actualFs = await vi.importActual<typeof import("node:fs")>("node:fs");
+    // 三个 tmp：good（合法 → promote）、stale（manifest sa-stale.json 已存在 → 删）、
+    // doomed（unlink ENOENT）
+    fs.writeFileSync(path.join(dir, "sa-good.json.tmp.111"), JSON.stringify(VALID_MANIFEST));
+    fs.writeFileSync(path.join(dir, "sa-stale.json"), JSON.stringify(VALID_MANIFEST));
+    fs.writeFileSync(path.join(dir, "sa-stale.json.tmp.222"), "{}");
+    fs.writeFileSync(path.join(dir, "sa-doomed.json.tmp.333"), "not json");
+    const doomedPath = path.join(dir, "sa-doomed.json.tmp.333");
+    unlinkSyncMock.mockImplementation((p: fs.PathLike) => {
+      if (String(p) === doomedPath) {
+        const err = new Error("ENOENT: file vanished") as NodeJS.ErrnoException;
+        err.code = "ENOENT";
+        throw err;
+      }
+      return actualFs.unlinkSync(p);
+    });
+
+    const result = await store.recoverTmpFiles();
+
+    // 整轮不中断：doomed 之外的 tmp 全部处理完
+    expect(result.recovered).toBe(1); // good promote
+    expect(result.deleted).toBe(1); // stale 删
+    // good 被提升为正式 manifest
+    expect(fs.existsSync(path.join(dir, "sa-good.json"))).toBe(true);
+    // 失败留痕（warn 级，含文件名）
+    expect(loggerMock.warn).toHaveBeenCalledWith(
+      expect.stringContaining("sa-doomed.json.tmp.333"),
+      expect.objectContaining({ detail: expect.stringContaining("ENOENT") }),
+    );
+    expect(loggerMock.warn).toHaveBeenCalledWith(expect.stringContaining("1 of 3 tmp file(s)"));
+  });
+
+  it("returns counts unchanged and no warnings when all tmp files succeed", async () => {
+    fs.writeFileSync(path.join(dir, "sa-ok.json.tmp.444"), JSON.stringify(VALID_MANIFEST));
+    const result = await store.recoverTmpFiles();
+    expect(result).toEqual({ deleted: 0, recovered: 1 });
+    expect(loggerMock.warn).not.toHaveBeenCalled();
+  });
+});

package/src/execution/__tests__/max-turns-to-watchdog-ms.test.ts

@@ -0,0 +1,113 @@
+// src/execution/__tests__/max-turns-to-watchdog-ms.test.ts
+//
+// U3（subagent-core-sink-design）：computeWatchdogMs 语义化更名 maxTurnsToWatchdogMs
+// + floor 语义文档化。本文件锚定换算纯函数语义：
+//   - floor 断言（设计 §4 S2）：maxTurnsToWatchdogMs(2) >= 1_800_000——zsw 曾自实现
+//     无 floor 版本致 maxTurns=2 被 10min 误杀（设计 §2.1 例 1），floor 是两宿主
+//     预算一致性的锚点（G1）。
+//   - 边界：0.5 轮 / 缺省（不挂 watchdog）/ 极大值。
+//
+// 纯函数换算，无 timer 参与，无需 fake timers。
+import { describe, expect, it, vi } from "vitest";
+
+// [LC-7/T7①] Mock 共享 logger：非法 env 值的 warn 留痕可被断言
+//（对齐 channel-registry-handshake.test.ts 模式；vi.mock 自动 hoist 到 import 前）。
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("../../core/logger.ts", () => ({
+  getLogger: () => loggerMock,
+}));
+
+import {
+  maxTurnsToWatchdogMs,
+  resolveSpawnWatchdogMs,
+  SPAWN_WATCHDOG_ENV,
+} from "../session-runner.ts";
+
+const MIN_MS = 60_000;
+/** watchdog floor（session-runner WATCHDOG_FLOOR_MINUTES=30 的毫秒值）。 */
+const FLOOR_MS = 30 * MIN_MS;
+/** Node setTimeout delay 安全域上界（>2^31-1 被置 1ms 立即触发，assertSafeTimerDelay 拦截域）。 */
+const TIMER_SAFE_MAX = 2 ** 31 - 1;
+
+describe("maxTurnsToWatchdogMs（U3 watchdog 换算，floor 语义）", () => {
+  it("floor 断言（S2）：maxTurns=2 → >= 1_800_000（floor 生效，非 2×5=10min）", () => {
+    expect(maxTurnsToWatchdogMs(2)).toBeGreaterThanOrEqual(1_800_000);
+    // 精确值锚定：floor 是 max 不是「至少再加余量」
+    expect(maxTurnsToWatchdogMs(2)).toBe(FLOOR_MS);
+  });
+
+  it("0.5 轮（小数）→ floor 30min（不出现 2.5min 的短 watchdog）", () => {
+    expect(maxTurnsToWatchdogMs(0.5)).toBe(FLOOR_MS);
+  });
+
+  it("maxTurns=6 → 恰为 floor 临界（max(30min, 30min)）", () => {
+    expect(maxTurnsToWatchdogMs(6)).toBe(FLOOR_MS);
+  });
+
+  it("线性段：maxTurns=20 → 100min；maxTurns=100 → 500min（M-1 长任务不被 30min 误杀）", () => {
+    expect(maxTurnsToWatchdogMs(20)).toBe(100 * MIN_MS);
+    expect(maxTurnsToWatchdogMs(100)).toBe(500 * MIN_MS);
+  });
+
+  it("极大值 → 保持纯算术结果（> 2^31-1 溢出域；挂载前由 assertSafeTimerDelay fail-fast 拦截）", () => {
+    expect(maxTurnsToWatchdogMs(Number.MAX_SAFE_INTEGER)).toBeGreaterThan(TIMER_SAFE_MAX);
+    expect(maxTurnsToWatchdogMs(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY);
+  });
+
+  it("上层防线：换算链路入口对极大值 fail-fast（resolveSpawnWatchdogMs(Infinity) 抛出）", () => {
+    expect(() => resolveSpawnWatchdogMs(Number.POSITIVE_INFINITY)).toThrow();
+  });
+
+  it("缺省（maxTurns 未传/null 且 env 未设）→ resolveSpawnWatchdogMs 返回 undefined（不挂 watchdog）", () => {
+    // 空串与未设同义（getEnvSpawnWatchdogMs 对 falsy raw 返回 undefined）；
+    // 显式 stub 防御宿主 shell export 污染（vitest.setup.ts 已在模块加载前净化）。
+    vi.stubEnv(SPAWN_WATCHDOG_ENV, "");
+    try {
+      expect(resolveSpawnWatchdogMs(undefined)).toBeUndefined();
+      expect(resolveSpawnWatchdogMs(null)).toBeUndefined();
+    } finally {
+      vi.unstubAllEnvs();
+    }
+  });
+
+  // [LC-7/T7①] env 非法值不再静默失效：warn 留痕（env 名 + 实际值 + 生效行为）。
+  it("[LC-7] env 设非法值（'30m' 非纯数字）→ undefined（不挂 watchdog）且 warn 留痕", () => {
+    vi.stubEnv(SPAWN_WATCHDOG_ENV, "30m");
+    try {
+      expect(resolveSpawnWatchdogMs(undefined)).toBeUndefined();
+      expect(loggerMock.warn).toHaveBeenCalledTimes(1);
+      const msg = String(loggerMock.warn.mock.calls[0]?.[0] ?? "");
+      expect(msg).toContain("XYZ_SUBAGENT_SPAWN_WATCHDOG_MS"); // env 变量名
+      expect(msg).toContain("30m"); // 实际值
+      expect(msg).toContain("NOT armed"); // 生效行为：等价关闭，运维可诊断「以为有兜底、实际裸奔」
+    } finally {
+      loggerMock.warn.mockClear();
+      vi.unstubAllEnvs();
+    }
+  });
+
+  it("[LC-7] env 设 <=0 → 同样 warn 留痕（不挂 watchdog，语义与非法值一致可见）", () => {
+    vi.stubEnv(SPAWN_WATCHDOG_ENV, "-5");
+    try {
+      expect(resolveSpawnWatchdogMs(undefined)).toBeUndefined();
+      expect(loggerMock.warn).toHaveBeenCalledTimes(1);
+      expect(String(loggerMock.warn.mock.calls[0]?.[0] ?? "")).toContain("-5");
+    } finally {
+      loggerMock.warn.mockClear();
+      vi.unstubAllEnvs();
+    }
+  });
+
+  it("[LC-7] env 未设（空串）→ 静默 undefined，零 warn（未配置不是异常，不制造噪音）", () => {
+    vi.stubEnv(SPAWN_WATCHDOG_ENV, "");
+    try {
+      expect(resolveSpawnWatchdogMs(undefined)).toBeUndefined();
+      expect(loggerMock.warn).not.toHaveBeenCalled();
+    } finally {
+      loggerMock.warn.mockClear();
+      vi.unstubAllEnvs();
+    }
+  });
+});

package/src/execution/__tests__/notify-ledger.test.ts

@@ -0,0 +1,294 @@
+// src/execution/__tests__/notify-ledger.test.ts
+//
+// T4③ 重投止损（PS-6）单测族：回执确认不可达时 attempts 上限 + 放弃终态
+// （设计 docs/design/subagent-core-unbounded-wait-audit.md §7.2 T4③ / §8.2 S-E）。
+//
+// 覆盖验收面：
+//   - ①回执不可匹配 → 重投至 NOTIFY_REDELIVERY_MAX_ATTEMPTS → 放弃：
+//     abandoned 终态 entry 落盘 + warn 含 subagent 标识与 subagents action:"list"
+//     恢复指引，此后零重投（同一条完成通知不无限唤醒 LLM）
+//   - ②放弃条目跨重启不复活：recoverFromSession 跳过 abandoned 差集，
+//     同 notifyId record 幂等拒绝，后续 watchdog/settled 零投递
+//   - ③未达上限时正常重投行为不变：照常超时重投，回执到达后照常销账
+//   - 放弃终态持久化的 compaction 补写：abandoned entry 被清除后按内存态补写
+//
+// 全族 fake timers（看门狗 120s 周期）；warn 断言经 configureCore 日志 sink 捕获
+// （core logger facade 动态解析宿主实现，见 agents-assembly.test.ts 同款）。
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  createNotifyLedger,
+  NOTIFY_ABANDONED_CUSTOM_TYPE,
+  NOTIFY_ACK_CUSTOM_TYPE,
+  NOTIFY_LEDGER_CUSTOM_TYPE,
+  NOTIFY_REDELIVERY_MAX_ATTEMPTS,
+  NOTIFY_WATCHDOG_MS,
+  _resetNotifyLedgerForTest,
+  type NotifyLedgerHost,
+} from "../notify-ledger.ts";
+import { configureCore, resetCoreForTests } from "../../core/host-services.ts";
+
+// ─── mock host ─────────────────────────────────────────────
+
+interface LedgerHostMock {
+  host: NotifyLedgerHost;
+  /** 追加的 plain custom entry（ledger/ack/abandoned 三列，含 customType）。与
+   *  sessionEntries 共享同一数组——送达 custom_message entry 也会落入（无 data 字段）。 */
+  entries: { type: string; customType: string; data?: Record<string, unknown> }[];
+  /** session entries 视图（回执扫描 + 恢复扫描的输入；与 entries 共享同一数组）。 */
+  sessionEntries: unknown[];
+  /** 送达消息（sendDelivery 调用）。 */
+  sentMessages: { customType: string; content: string; display: boolean; details?: unknown }[];
+  /** settled 边沿回调（测试手动触发模拟 pi agent_settled 事件）。 */
+  settledHandlers: Array<() => void>;
+  setIdle(idle: boolean): void;
+  /** 送达是否同步落盘为 custom_message entry。false = 模拟回执不可匹配（PS-6 触发态）。 */
+  deliverPersists: { value: boolean };
+}
+
+function makeLedgerHost(): LedgerHostMock {
+  const entries: LedgerHostMock["entries"] = [];
+  const sessionEntries: unknown[] = entries;
+  const sentMessages: LedgerHostMock["sentMessages"] = [];
+  const settledHandlers: Array<() => void> = [];
+  const idle = { value: true };
+  const deliverPersists = { value: true };
+  const host: NotifyLedgerHost = {
+    appendLedgerEntry: (customType, data) => {
+      entries.push({ type: "custom", customType, data: data as Record<string, unknown> });
+    },
+    readSessionEntries: () => sessionEntries,
+    isIdle: () => idle.value,
+    onAgentSettled: (handler) => {
+      settledHandlers.push(handler);
+    },
+    sendDelivery: (message) => {
+      sentMessages.push(message);
+      if (deliverPersists.value) {
+        sessionEntries.push({
+          type: "custom_message",
+          customType: message.customType,
+          content: message.content,
+          display: message.display,
+          details: message.details,
+        });
+      }
+    },
+  };
+  return {
+    host,
+    entries,
+    sessionEntries,
+    sentMessages,
+    settledHandlers,
+    setIdle: (v: boolean) => {
+      idle.value = v;
+    },
+    deliverPersists,
+  };
+}
+
+/** 触发一次 settled 边沿（模拟 pi agent_settled 事件）。 */
+function fireSettled(mock: LedgerHostMock): void {
+  for (const handler of mock.settledHandlers) handler();
+}
+
+/** 未终态号差集：ledger entry 的 notifyId −（ack ∪ abandoned）的 notifyId。 */
+function unsettledDiff(mock: LedgerHostMock): Set<string> {
+  const ledgerIds = new Set<string>();
+  const settled = new Set<string>();
+  for (const e of mock.entries) {
+    if (e.customType !== NOTIFY_LEDGER_CUSTOM_TYPE && e.customType !== NOTIFY_ACK_CUSTOM_TYPE && e.customType !== NOTIFY_ABANDONED_CUSTOM_TYPE) {
+      continue;
+    }
+    const notifyId = e.data?.["notifyId"];
+    if (typeof notifyId !== "string") continue;
+    if (e.customType === NOTIFY_LEDGER_CUSTOM_TYPE) ledgerIds.add(notifyId);
+    else settled.add(notifyId);
+  }
+  for (const id of settled) ledgerIds.delete(id);
+  return ledgerIds;
+}
+
+function abandonedEntries(mock: LedgerHostMock): { data?: Record<string, unknown> }[] {
+  return mock.entries.filter((e) => e.customType === NOTIFY_ABANDONED_CUSTOM_TYPE);
+}
+
+/** 从日志 sink 中取放弃 warn（区别于分桶 warn「notify delivery bucket [...]」）。 */
+function abandonedWarns(logs: Array<{ level: string; message: string; data?: unknown }>): Array<{
+  level: string;
+  message: string;
+  data?: unknown;
+}> {
+  return logs.filter((l) => l.level === "warn" && l.message.includes("abandoned"));
+}
+
+// ─── T4③ 重投止损（PS-6） ─────────────────────────────────
+
+describe("NotifyLedger — T4③ 重投止损（PS-6）", () => {
+  let logCalls: Array<{ level: string; component: string; message: string; data?: unknown }>;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    logCalls = [];
+    configureCore({
+      dataRoot: () => "/fake-notify-ledger-data-root",
+      log: (level, component, message, data) => {
+        logCalls.push({ level, component, message, data });
+      },
+    });
+    _resetNotifyLedgerForTest();
+  });
+  afterEach(() => {
+    _resetNotifyLedgerForTest();
+    resetCoreForTests();
+    vi.useRealTimers();
+  });
+
+  it("① 回执不可匹配 → 重投至 attempts 上限后放弃：abandoned 终态 entry + warn 含恢复指引，此后零重投", () => {
+    const mock = makeLedgerHost();
+    // 回执永不可匹配（模拟 compaction 清除送达 entry —— PS-6 触发态）
+    mock.deliverPersists.value = false;
+    const ledger = createNotifyLedger(mock.host);
+
+    ledger.record("sa-cap", "content", { notifyId: "sa-cap", id: "sa-cap", agent: "worker" });
+    ledger.attemptDeliver(); // 第 1 次投递（attempts=1）
+    expect(mock.sentMessages).toHaveLength(1);
+
+    // 未达上限：每周期照常超时重投（共 4 次重投，attempts 累至上限）
+    for (let i = 2; i <= NOTIFY_REDELIVERY_MAX_ATTEMPTS; i += 1) {
+      vi.advanceTimersByTime(NOTIFY_WATCHDOG_MS);
+      expect(mock.sentMessages).toHaveLength(i);
+    }
+    expect(abandonedEntries(mock)).toHaveLength(0);
+    expect(ledger.waitingReceiptCount()).toBe(1);
+
+    // 第 5 个周期：attempts 已达上限仍无回执 → 放弃，不再重投
+    vi.advanceTimersByTime(NOTIFY_WATCHDOG_MS);
+    expect(mock.sentMessages).toHaveLength(NOTIFY_REDELIVERY_MAX_ATTEMPTS); // 零新增
+    // 终态 entry 落盘（与 ack 同形：{ v:1, notifyId }）
+    const abandoned = abandonedEntries(mock);
+    expect(abandoned).toHaveLength(1);
+    expect(abandoned[0]?.data).toEqual({ v: 1, notifyId: "sa-cap" });
+    // 账面摘除：pending / waiting 归零，差集为空（ledger − ack − abandoned）
+    expect(ledger.pendingCount()).toBe(0);
+    expect(ledger.waitingReceiptCount()).toBe(0);
+    expect(unsettledDiff(mock)).toEqual(new Set());
+    // 放弃不计入 watchdogReplays 桶（该桶口径 = 实际重投条数 = 上限 − 1）
+    expect(ledger.deliveryMetrics().watchdogReplays).toBe(NOTIFY_REDELIVERY_MAX_ATTEMPTS - 1);
+
+    // warn：含 subagent 标识（agent 名）与 subagents action:"list" 恢复指引；
+    // notifyId / attempts 动态值在 data（D4 约定，msg 近固定 key）
+    const warns = abandonedWarns(logCalls);
+    expect(warns).toHaveLength(1);
+    expect(warns[0]?.component).toBe("subagents");
+    expect(warns[0]?.message).toContain("worker");
+    expect(warns[0]?.message).toContain('subagents action:"list"');
+    expect(warns[0]?.data).toEqual({ notifyId: "sa-cap", attempts: NOTIFY_REDELIVERY_MAX_ATTEMPTS });
+
+    // 止损后看门狗空转：同一条通知不无限重复注入
+    vi.advanceTimersByTime(NOTIFY_WATCHDOG_MS * 3);
+    expect(mock.sentMessages).toHaveLength(NOTIFY_REDELIVERY_MAX_ATTEMPTS);
+
+    // 放弃是终态：同 notifyId 再 record 被幂等拒绝（绝不重发）
+    expect(ledger.record("sa-cap", "content", { notifyId: "sa-cap" })).toBe(false);
+
+    ledger.dispose();
+  });
+
+  it("② 放弃条目重启恢复不复活：recoverFromSession 跳过 abandoned 差集，watchdog/settled 零投递", () => {
+    const mock = makeLedgerHost();
+    // 模拟重启前落盘：s-gone 已放弃（ledger + abandoned 两列），s-live 未销账未放弃
+    mock.sessionEntries.push(
+      { type: "custom", customType: NOTIFY_LEDGER_CUSTOM_TYPE, data: { v: 1, notifyId: "s-gone", content: "cg", record: { notifyId: "s-gone", agent: "gone-agent" } } },
+      { type: "custom", customType: NOTIFY_ABANDONED_CUSTOM_TYPE, data: { v: 1, notifyId: "s-gone" } },
+      { type: "custom", customType: NOTIFY_LEDGER_CUSTOM_TYPE, data: { v: 1, notifyId: "s-live", content: "cl", record: { notifyId: "s-live" } } },
+    );
+    mock.setIdle(false); // busy：恢复路径的 attemptDeliver 挂 pending，隔离投递时机
+
+    const ledger = createNotifyLedger(mock.host);
+    // 仅 s-live 重放；s-gone 被放弃终态挡住
+    expect(ledger.recoverFromSession()).toBe(1);
+    expect(mock.sentMessages).toHaveLength(0);
+    expect(ledger.pendingCount()).toBe(1);
+
+    // 放弃号幂等拒绝（重启后 record 也不复活）
+    expect(ledger.record("s-gone", "cg", { notifyId: "s-gone" })).toBe(false);
+
+    // 看门狗多周期 + settled 边沿：s-gone 零投递
+    vi.advanceTimersByTime(NOTIFY_WATCHDOG_MS * 3);
+    expect(mock.sentMessages).toHaveLength(0);
+    fireSettled(mock);
+    expect(mock.sentMessages).toHaveLength(0);
+
+    // 对照：idle 后 s-live 正常补投（证明差集重放本身未被破坏）
+    mock.setIdle(true);
+    fireSettled(mock);
+    expect(mock.sentMessages).toHaveLength(1);
+    expect(mock.sentMessages[0]?.details).toMatchObject({ notifyId: "s-live" });
+
+    ledger.dispose();
+  });
+
+  it("③ 未达上限时正常重投行为不变：照常超时重投，回执到达后照常销账", () => {
+    const mock = makeLedgerHost();
+    // 前三轮回执不可匹配（重投路径）
+    mock.deliverPersists.value = false;
+    const ledger = createNotifyLedger(mock.host);
+
+    ledger.record("sa-ok", "content", { notifyId: "sa-ok", id: "sa-ok", agent: "worker" });
+    ledger.attemptDeliver(); // 第 1 次投递
+    expect(mock.sentMessages).toHaveLength(1);
+
+    // 两个周期无回执 → 两次照常重投（attempts=3 < 上限），无任何放弃痕迹
+    vi.advanceTimersByTime(NOTIFY_WATCHDOG_MS * 2);
+    expect(mock.sentMessages).toHaveLength(3);
+    expect(abandonedEntries(mock)).toHaveLength(0);
+    expect(abandonedWarns(logCalls)).toHaveLength(0);
+    expect(ledger.deliveryMetrics().watchdogReplays).toBe(2);
+
+    // 回执恢复可达：本周期重投落盘 → settled 边沿销账（既有 at-least-once 闭环不变）
+    mock.deliverPersists.value = true;
+    vi.advanceTimersByTime(NOTIFY_WATCHDOG_MS); // 第 3 次重投（本次落盘）
+    expect(mock.sentMessages).toHaveLength(4);
+    fireSettled(mock);
+    expect(unsettledDiff(mock)).toEqual(new Set());
+    expect(ledger.waitingReceiptCount()).toBe(0);
+    expect(abandonedEntries(mock)).toHaveLength(0);
+
+    ledger.dispose();
+  });
+
+  it("放弃终态持久化：abandoned entry 被 compaction 清除后按内存态补写，重启仍不复活", () => {
+    const mock = makeLedgerHost();
+    mock.deliverPersists.value = false;
+    const ledger = createNotifyLedger(mock.host);
+
+    ledger.record("sa-cp", "content", { notifyId: "sa-cp", id: "sa-cp", agent: "worker" });
+    ledger.attemptDeliver();
+    vi.advanceTimersByTime(NOTIFY_WATCHDOG_MS * NOTIFY_REDELIVERY_MAX_ATTEMPTS); // 达上限放弃
+    expect(abandonedEntries(mock)).toHaveLength(1);
+
+    // 模拟 compaction 只清掉 abandoned entry（ledger entry 保留）
+    const idx = mock.entries.findIndex((e) => e.customType === NOTIFY_ABANDONED_CUSTOM_TYPE);
+    expect(idx).toBeGreaterThanOrEqual(0);
+    mock.entries.splice(idx, 1);
+
+    // compaction 降级补写放弃终态（内存是权威）
+    expect(ledger.compactionCheck()).toBe(1);
+    expect(abandonedEntries(mock)).toHaveLength(1);
+    ledger.dispose();
+
+    // 重启：abandoned 在场 → 不复活不重投
+    const mock2 = makeLedgerHost();
+    mock2.sessionEntries.push(...mock.entries);
+    mock2.setIdle(false);
+    const ledger2 = createNotifyLedger(mock2.host);
+    expect(ledger2.recoverFromSession()).toBe(0);
+    mock2.setIdle(true);
+    fireSettled(mock2);
+    expect(mock2.sentMessages).toHaveLength(0);
+    ledger2.dispose();
+  });
+});