@zhushanwen/session-delivery 1.0.0 → 1.1.0

package/dist/index.d.mts

@@ -88,13 +88,12 @@ interface DeliveryPort {
      * 处理）；void / `{accepted:true}` = 受理成功。旧实现返回 void 兼容。
      *
      * settle 契约：返回 promise 时实现必须 settle（resolve 或 reject）——悬挂的
-     * promise 会让内核 in-flight 防重永久占位。内核侧按控制面单请求粒度设有界兜底
-     * （默认 60s，C-proc-19）：超时按发送失败收口（warn 留痕 + 走错误重试链）。
-     * 已接受代价：迟到的原请求在超时强制失败后仍可能到达底层通道，与重试构成重复
-     * 投递；通道内判重由适配器/对端按裸标记（clientUuid）负责，内核不建第二套判重。
+     * promise 会让内核 in-flight 防重永久占位、通路停摆。信任边界内不设防
+     * （ADR-0122 范围纪律）：本机操作无响应 = 底层已挂，内核不建墙钟兜底，
+     * 处置 = 用户显式失败 + 重启应用。
      */
     send(msg: DeliveryMessage, intent: DeliveryIntent): Promise<SendReceipt | void> | SendReceipt | void;
-    /** agent_settled 边沿订阅（D8）。缺省时内核退化退避轮询。返回退订函数。 */
+    /** agent_settled 边沿订阅（D8）。缺省时 busy 条目留守至外部 flush/send 触发。返回退订函数。 */
     subscribeSettled?(cb: () => void): () => void;
 }
 /** 内核配置（D4 策略默认值）。 */
@@ -106,13 +105,6 @@ interface DeliveryConfig {
     /** 合批依赖谓词（D4 must-fix #1）。true 时 send() 走合批窗口，false/缺省时立即投。
      *  禁止用 isIdle 代替。 */
     mergeHoldActive?: () => boolean;
-    /** 退避参数。 */
-    backoff?: {
-        ms: number;
-        max: number;
-    };
-    /** watch-dog 复核间隔（ms）。默认 30_000。 */
-    watchdogMs?: number;
     /** 去重配置（条数 LRU）。 */
     dedupe?: {
         maxKeys: number;
@@ -133,8 +125,12 @@ interface DeliveryConfig {
      * 锚定在受理时点，后移到送达会让 agent 工具调用阻塞至目标 session 当前 turn 结束
      * （steer 类车道可达数十秒）。本注释即接口口径权威声明。
      *
+     * outcome 'rejected' = 失败终局通知（ADR-0122 首败即停：send 失败一次即移除条目并
+     * 逐条回调；断连事件 failInFlight 转 failed 终态同样逐条回调）。重试决策归消费方，
+     * 内核不建自动重试。
+     *
      * 异常契约：实现不应抛——回调异常由内核捕获并 warn 留痕，不影响条目状态机与
-     * 其余条目的回调（回调异常 ≠ 投递失败，不进错误重试链）。
+     * 其余条目的回调（回调异常 ≠ 投递失败，不进失败重试链）。
      */
     onSettled?: (msg: DeliveryMessage, outcome: 'delivered' | 'rejected') => void;
 }
@@ -165,7 +161,8 @@ type DeliveryLane = 'direct' | 'steer' | 'queued';
  * - in-flight → delivered：送达回执到达（message_end 标记命中 / 适配器确认，D2）
  * - in-flight → queued：对账回收重投（滞留收回，D3；cancel 部分收回的其余条目同路径）
  * - in-flight/queued → cancelled：用户撤销（delivery.cancel）
- * - in-flight → failed：重试耗尽（sendAttempts 超 backoff.max，既有上限语义保留）
+ * - in-flight → failed：断连事件驱动的未确认终局（failInFlight，ADR-0122——pi 连接
+ *   断开时结果未知，显式失败交用户处置）
  * - failed → queued：用户重试（resync 单条重报）；failed → cancelled：用户移除
  * 帧投影四态差异：cancelled 不进 session.delivery 帧（D5③），协议侧帧 state 无此值。
  */
@@ -187,8 +184,6 @@ interface DeliveryEntry {
     createdAt: number;
     /** 最近一次状态迁移时间（epoch ms）。 */
     updatedAt: number;
-    /** 已尝试投递次数（重试耗尽判定源：sendAttempts > backoff.max → failed，§3.4）。 */
-    sendAttempts: number;
     /** 终态落定时间（epoch ms；delivered/failed/cancelled 时有值，tombstone 提取源）。 */
     settledAt?: number;
 }
@@ -198,6 +193,11 @@ interface DeliveryEntry {
  * cancelled tombstone 防「cancel 确认帧断连窗口丢失 → 已撤销消息被 resync 复活」。
  * 栖身 runtime 进程内存、不跨 runtime 重启；reattach 场景（判重表已清空）判重锚
  * 回落 transcript 全量标记扫描（D5②/§3.4）。
+ *
+ * 语义边界（pi1-disposition-chat-flow D1②）：tombstone 语义从「送达事实」扩为
+ * 「离开系统的事实」——handled 条目（pi 接管输入等受理即终局形态）复用送达确认
+ * 原语写入本记录，终态固定为 delivered（复用既有送达终态，不新造终态形态；对账器
+ * 见 tombstone 不重投，继承断线重连 resync 判重防线）。state 联合仅两值不变。
  */
 interface DeliveryTombstone {
     id: string;
@@ -230,17 +230,17 @@ interface DeliveryEntriesProjection {
 /**
  * 投递所有权内核实现：createDelivery（v2）。
  *
- * 在 v1 投递循环（入队 → dedupe → 合批窗口 → busy gate → port.send → backoff
- * 重试 → settled 边沿/watchdog 驱动）之上升级为条目制所有权内核（设计
- * .tmp/tech-design/delivery-ownership-kernel.md §3 D9①②③⑤ / D5②③ / D3，单元 u1）。
- * 零 pi 依赖不变：确认/回收由适配器（runtime registry）调 handle 方法驱动。
+ * 在 v1 投递循环（入队 → dedupe → 合批窗口 → busy gate → port.send → settled 边沿
+ * 驱动）之上升级为条目制所有权内核（设计 .tmp/tech-design/delivery-ownership-kernel.md
+ * §3 D9①②③⑤ / D5②③ / D3，单元 u1）。零 pi 依赖不变：确认/回收由适配器（runtime
+ * registry）调 handle 方法驱动。
  *
  * 五态状态机（D9①，types.ts 迁移表）+ 本文件登记的两处实施扩展：
  * - queued → in-flight：出站投递被受理（两阶段回执第一阶段，D2）
  * - in-flight → delivered：confirmDelivered（送达回执，D2）
  * - in-flight → queued：requeue（对账回收重投，D3）
  * - queued/failed → cancelled：cancel（本地移除 + tombstone / 用户 × 移除）
- * - in-flight → failed：重试耗尽（sendAttempts > backoff.max，v1 语义保留）
+ * - in-flight → failed：断连事件驱动的未确认终局（failInFlight，ADR-0122）
  * - failed → queued：requeue（用户重试/resync 单条重报）
  * - [扩展①] queued → delivered：confirmDelivered 也接受 queued 态——服务 reattach
  *   场景 rebuild 直确认重建（D3②：适配器扫描 transcript 判 delivered 后 send 重建
@@ -255,16 +255,26 @@ interface DeliveryEntriesProjection {
  *   已由底层通道受理——queued → in-flight + 出批 + checked waiter 受理口径 resolve。
  *   合批分段中途失败时已登记段留守 in-flight（等回执/对账），仅未受理段走失败面。
  *
+ * 失败语义（ADR-0122 首败即停，2026-10-05 用户裁决，backoff 自动重试链退役）：
+ * port.send 失败（含 accepted:false）一次即收口——checked 条目 reject + 从内核移除；
+ * 非 checked 条目 onSettled('rejected') 逐条显式上报 + 从内核移除。重试决策归消费方
+ * （人看页面通知、agent 收失败回执），内核只做忠实投递与事实上报。
+ *
  * onSettled 记账口径（D9⑤ 升级）：
  * - 'delivered' = 送达口径：仅 confirmDelivered 驱动回调（受理只转 in-flight，
  *   不回调——受理 ≠ 送达的机制化落地）；per-message 契约（ext-simplify-08）在
  *   confirmDelivered 路径同样成立——对每条消息各回调一次，msg 为该条原始消息
  *   （非 composed 合批消息），additive meta（notifyId 等）随原消息引用原样
  *   透传到回调，内核不读不改。
- * - 'rejected' = 重试耗尽通知（v1 时点不变，判定源 = sendAttempts > max，仅通知）。
+ * - 'rejected' = 失败终局通知（send 首败移除 / failInFlight 断连未确认，仅通知）。
  * - 显式例外：sendChecked 的同步 settle 维持受理口径不变——promise 在 port.send
  *   受理成功时点 resolve（session_manager send 的 {queued:true} 契约锚，D9⑤ 锁定），
- *   与 onSettled 送达口径正交。
+ *   与 onSettled 送达口径正交。补充受理口径的第二 settle 路径（F1-11）：条目在
+ *   port.send promise settle 之前已终局 delivered 时（handled 终局路径——适配器在
+ *   port.send 实现内部先 confirmDelivered 再让 promise settle，finalizeEntry 同步
+ *   摘批后 onSendOk 的 settleChecked 只 settle 当前批成员），受理确认随 confirmDelivered
+ *   同步了结（resolveWaitersOf）——契约「受理成功即 resolve」对命令条目成立，
+ *   waiter 不因 settle 时序倒挂滞留。
  *
  * 双视图（D9②/D5③）：entriesFull() = 全量视图（活跃条目 + 全量 tombstone，对账/
  * 判重消费）；projection() = 投影视图（活跃全量 + delivered 最近 50 条完整条目，
@@ -277,10 +287,12 @@ interface DeliveryEntriesProjection {
  * id 的消息不参与幂等判重（v1「无 dedupe 配置不去重」语义保持）。
  *
  * 其余 v1 机制逐条保持：busy gate（isIdle + 内核在途内查双条件——hasPendingMessages
- * 自镜像四件套已按 msg-pipeline-debloat D2 拆除，busy 判定内查 active 表）、backoff
- * 有限重试、合批窗口、dedupe LRU、30s watchdog、dispose 语义（丢弃不触发
- * onSettled、checked 挂账 reject）。depth() 口径保持 v1 = 尚未受理的消息数
- * （受理转 in-flight 后不计；「在途未确认」数经 entriesFull() 全量视图消费）。
+ * 自镜像四件套已按 msg-pipeline-debloat D2 拆除，busy 判定内查 active 表）、合批窗口、
+ * settled 边沿驱动、dedupe LRU、dispose 语义（丢弃不触发 onSettled、checked 挂账
+ * reject）。[ADR-0122 退役登记] backoff 自动重试链、port.send settle 挂死兜底
+ * （60s）、watchdog 30s 定时复核、无订阅装配 busy 退避轮询——时间平抑/补偿类机制
+ * 全部删除，busy 等待归 settled 边沿与外部触发。depth() 口径保持 v1 = 尚未受理的
+ * 消息数（受理转 in-flight 后不计；「在途未确认」数经 entriesFull() 全量视图消费）。
  */
 
 /**
@@ -321,6 +333,19 @@ interface DeliverySubmitOptions {
      * 'acceptance' 并登记来源清单（ADR-0074 词条）。
      */
     receiptAnchor?: 'marker' | 'acceptance';
+    /**
+     * 无标记条目标志（pi1-disposition-chat-flow D14⑥ 起源；技能/芯片通路并入后为
+     * 「出站不注标条目」统一标志——命令 / 手打 skill 与 prompt 模板 / `<taiji-skill>`
+     * 芯片注入文本）。true = 条目出站文本不带投递标记、终局凭据不走 message_end
+     * 标记回执（pi disposition 响应 / 断连事件驱动，适配器职责）。内核两处行为：
+     * - 组批隔离：与普通条目合批会被 buildBatchPayload 以 BATCH_SEP 拼接，pi 命令解析
+     *   与适配器全文身份匹配对拼接文本必然失效——批内含无标记条目时只取队首一条单独
+     *   成批（isolateUnmarkedEntry）。
+     * - 首败即停（ADR-0122 统一语义后不再差异化，全条目同形态）。
+     * 'acceptance' 锚条目（agent 通路）出站同样无标记但走合批、以受理即终态，不置
+     * 本标志。
+     */
+    unmarked?: boolean;
 }
 /**
  * send() 受理结果（b31-D6：失败双表面窄口收口）。调用方忽略返回值不受影响
@@ -373,6 +398,13 @@ interface DeliveryHandleV2 extends DeliveryHandle {
      * 仅未受理段走失败面——已进底层通道的文本不再误报「投递失败」。
      */
     confirmAccepted(id: string): boolean;
+    /**
+     * 断连事件驱动的显式失败终局（ADR-0122 命令终局事件化的断连腿）：把全部 in-flight
+     * 条目批量转 failed 终态（留守活跃集等用户处置：resync 重试 / cancel 移除），
+     * 逐条 onSettled('rejected') 显式上报。queued 条目不触碰（未触达底层通道，随队列
+     * 存活，重连后照常投递）。幂等：无 in-flight 条目返回 0。@returns 终态化条数。
+     */
+    failInFlight(reason: string): number;
     /**
      * 回收重置 queued 至队首（保持 ids 相对序，D3 own 处置/failed 重试）。
      * 只接受 in-flight/failed；queued 幂等跳过（已在队列）；cancelled/delivered

package/dist/index.mjs

@@ -44,12 +44,9 @@ var LruSet = class {
 // src/delivery.ts
 var DEFAULT_CONFIG = {
   intent: "interrupt-at-turn-boundary",
-  mergeWindowMs: 0,
-  backoff: { ms: 100, max: 50 },
-  watchdogMs: 3e4
+  mergeWindowMs: 0
 };
 var DEFAULT_DELIVERED_WINDOW = 50;
-var PORT_SEND_SETTLE_TIMEOUT_MS = 6e4;
 function isThenable(v) {
   return !!v && typeof v.then === "function";
 }
@@ -81,6 +78,10 @@ function buildBatchPayload(messages) {
     payload: images.length > 0 ? { kind: "text", content, images } : { kind: "text", content }
   };
 }
+function isolateUnmarkedEntry(batch) {
+  const firstUnmarked = batch.find((e) => e.unmarked);
+  return firstUnmarked !== void 0 ? [firstUnmarked] : batch;
+}
 function settleChecked(batch, err, checkedPending) {
   const rejected = /* @__PURE__ */ new Set();
   if (checkedPending.length === 0) return rejected;
@@ -118,8 +119,7 @@ function resolveWarnSink(config) {
 function createDelivery(port, config) {
   const cfg = {
     ...DEFAULT_CONFIG,
-    ...config,
-    backoff: config?.backoff ?? DEFAULT_CONFIG.backoff
+    ...config
   };
   const active = [];
   const activeIndex = /* @__PURE__ */ new Map();
@@ -128,11 +128,7 @@ function createDelivery(port, config) {
   const checkedPending = [];
   let inflightBatch = [];
   let inFlight = false;
-  let sendAttempts = 0;
   let mergeTimer;
-  let backoffTimer;
-  let hangTimer;
-  let watchdogTimer;
   let disposed = false;
   let settledUnsub;
   let missingKeyWarned = false;
@@ -155,7 +151,6 @@ function createDelivery(port, config) {
       payload: e.payload,
       createdAt: e.createdAt,
       updatedAt: e.updatedAt,
-      sendAttempts: e.sendAttempts,
       ...e.settledAt !== void 0 ? { settledAt: e.settledAt } : {}
     };
   }
@@ -207,6 +202,7 @@ function createDelivery(port, config) {
     e.settledAt = ts;
     tombstones.set(e.id, { id: e.id, state, lane: e.lane, settledAt: ts });
     if (state === "delivered") {
+      resolveWaitersOf(e);
       deliveredLog.push(e);
       if (deliveredLog.length > DEFAULT_DELIVERED_WINDOW) deliveredLog.shift();
     }
@@ -225,6 +221,14 @@ function createDelivery(port, config) {
       }
     }
   }
+  function resolveWaitersOf(e) {
+    for (let i = checkedPending.length - 1; i >= 0; i--) {
+      if (checkedPending[i].entry === e) {
+        checkedPending[i].resolve();
+        checkedPending.splice(i, 1);
+      }
+    }
+  }
   function clearMergeTimer() {
     if (mergeTimer !== void 0) {
       clearTimeout(mergeTimer);
@@ -242,18 +246,6 @@ function createDelivery(port, config) {
     clearMergeTimer();
     armMergeTimer();
   }
-  function clearBackoffTimer() {
-    if (backoffTimer !== void 0) {
-      clearTimeout(backoffTimer);
-      backoffTimer = void 0;
-    }
-  }
-  function clearHangTimer() {
-    if (hangTimer !== void 0) {
-      clearTimeout(hangTimer);
-      hangTimer = void 0;
-    }
-  }
   function ensureSettledSub() {
     if (settledUnsub || !port.subscribeSettled) return;
     settledUnsub = port.subscribeSettled(() => {
@@ -269,30 +261,12 @@ function createDelivery(port, config) {
       settledUnsub = void 0;
     }
   }
-  function startWatchdog() {
-    if (watchdogTimer !== void 0) return;
-    if (!port.subscribeSettled) return;
-    watchdogTimer = setInterval(() => {
-      if (disposed || inFlight) return;
-      if (!hasQueuedEntries()) return;
-      if (!isBusySafe()) {
-        flush();
-      }
-    }, cfg.watchdogMs);
-  }
-  function stopWatchdog() {
-    if (watchdogTimer !== void 0) {
-      clearInterval(watchdogTimer);
-      watchdogTimer = void 0;
-    }
-  }
   function attemptSend() {
     if (inflightBatch.some((e) => !inRegistry(e))) {
       inflightBatch = inflightBatch.filter((e) => inRegistry(e));
     }
     if (inflightBatch.length === 0) {
       inFlight = false;
-      sendAttempts = 0;
       pump();
       return;
     }
@@ -302,30 +276,9 @@ function createDelivery(port, config) {
     try {
       const result = port.send(composed, intent);
       if (isThenable(result)) {
-        let settled = false;
-        clearHangTimer();
-        hangTimer = setTimeout(() => {
-          if (settled || disposed) return;
-          settled = true;
-          hangTimer = void 0;
-          warn(
-            `port.send hung; force-failed after ${PORT_SEND_SETTLE_TIMEOUT_MS}ms (retries may duplicate-deliver; see DeliveryPort.send settle contract)`
-          );
-          onSendFail(new Error(`port.send promise did not settle within ${PORT_SEND_SETTLE_TIMEOUT_MS}ms`));
-        }, PORT_SEND_SETTLE_TIMEOUT_MS);
         result.then(
-          (receipt) => {
-            if (settled) return;
-            settled = true;
-            clearHangTimer();
-            onSendReceipt(receipt);
-          },
-          (err) => {
-            if (settled) return;
-            settled = true;
-            clearHangTimer();
-            onSendFail(err);
-          }
+          (receipt) => onSendReceipt(receipt),
+          (err) => onSendFail(err)
         );
       } else {
         onSendReceipt(result);
@@ -346,7 +299,6 @@ function createDelivery(port, config) {
     const batch = inflightBatch;
     inFlight = false;
     inflightBatch = [];
-    sendAttempts = 0;
     settleChecked(batch, void 0, checkedPending);
     let changed = false;
     for (const e of batch) {
@@ -366,49 +318,24 @@ function createDelivery(port, config) {
   }
   function onSendFail(err) {
     if (disposed) return;
-    sendAttempts++;
-    for (const e of inflightBatch) e.sendAttempts = sendAttempts;
-    const rejected = settleChecked(inflightBatch, err, checkedPending);
-    if (rejected.size > 0) {
-      inflightBatch = inflightBatch.filter((e) => !rejected.has(e));
-      for (const e of rejected) removeActive(e);
-      notifyChange();
-    }
-    if (inflightBatch.length === 0) {
-      inFlight = false;
-      inflightBatch = [];
-      sendAttempts = 0;
-      warn("port.send failed", err);
-      pump();
-      return;
+    const batch = inflightBatch;
+    inFlight = false;
+    inflightBatch = [];
+    warn("port.send failed (first-failure stop, no kernel retry)", err);
+    const rejected = settleChecked(batch, err, checkedPending);
+    let changed = false;
+    for (const e of batch) {
+      if (!inRegistry(e)) continue;
+      if (rejected.has(e)) continue;
+      callOnSettled(e.msg, "rejected");
     }
-    if (sendAttempts > cfg.backoff.max) {
-      const failedBatch = inflightBatch;
-      inFlight = false;
-      inflightBatch = [];
-      sendAttempts = 0;
-      warn("port.send failed after max retries", err);
-      let changed = false;
-      for (const e of failedBatch) {
-        if (disposed) break;
-        if (!inRegistry(e)) continue;
-        e.state = "failed";
-        const ts = now();
-        e.updatedAt = ts;
-        e.settledAt = ts;
-        changed = true;
-        callOnSettled(e.msg, "rejected");
-      }
-      if (changed) notifyChange();
-      pump();
-      return;
+    for (const e of batch) {
+      if (!inRegistry(e)) continue;
+      removeActive(e);
+      changed = true;
     }
-    if (sendAttempts === 1) warn("port.send failed, retrying with backoff", err);
-    backoffTimer = setTimeout(() => {
-      backoffTimer = void 0;
-      if (disposed || !inFlight) return;
-      attemptSend();
-    }, cfg.backoff.ms);
+    if (changed) notifyChange();
+    pump();
   }
   function pump() {
     if (disposed || inFlight) return;
@@ -418,43 +345,29 @@ function createDelivery(port, config) {
         if (inRegistry(w.entry) && w.entry.state === "queued") batch.push(w.entry);
       }
       if (batch.length > 0) {
-        inflightBatch = batch;
+        inflightBatch = isolateUnmarkedEntry(batch);
         inFlight = true;
-        sendAttempts = 0;
         attemptSend();
         return;
       }
     }
     if (hasQueuedEntries()) {
-      scheduleFlush(0);
+      scheduleFlush();
       return;
     }
-    if (checkedPending.length === 0) stopWatchdog();
   }
   function doSend() {
     if (disposed || inFlight) return;
-    const batch = active.filter((e) => e.state === "queued");
+    const batch = isolateUnmarkedEntry(active.filter((e) => e.state === "queued"));
     if (batch.length === 0) return;
     inFlight = true;
     inflightBatch = batch;
-    sendAttempts = 0;
     attemptSend();
   }
-  function scheduleFlush(attempt) {
+  function scheduleFlush() {
     if (disposed || !hasQueuedEntries()) return;
     if (inFlight) return;
-    clearBackoffTimer();
-    if (isBusySafe() && attempt < cfg.backoff.max) {
-      if (port.subscribeSettled) {
-        startWatchdog();
-        return;
-      }
-      backoffTimer = setTimeout(() => {
-        backoffTimer = void 0;
-        scheduleFlush(attempt + 1);
-      }, cfg.backoff.ms);
-      return;
-    }
+    if (isBusySafe()) return;
     doSend();
   }
   const warnSink = resolveWarnSink(config);
@@ -487,10 +400,10 @@ function createDelivery(port, config) {
       payload: msg.payload,
       createdAt: ts,
       updatedAt: ts,
-      sendAttempts: 0,
       msg,
       cancelRequested: false,
-      receiptAnchor: opts?.receiptAnchor ?? "marker"
+      receiptAnchor: opts?.receiptAnchor ?? "marker",
+      unmarked: opts?.unmarked ?? false
     };
     active.push(entry);
     activeIndex.set(entry.id, entry);
@@ -520,7 +433,7 @@ function createDelivery(port, config) {
     }
     clearMergeTimer();
     ensureSettledSub();
-    scheduleFlush(0);
+    scheduleFlush();
     return { kind: "accepted", id: entry.id };
   }
   async function sendChecked(msg, opts) {
@@ -540,7 +453,6 @@ function createDelivery(port, config) {
       if (!inFlight) {
         inflightBatch = [entry];
         inFlight = true;
-        sendAttempts = 0;
         attemptSend();
       }
     });
@@ -548,7 +460,7 @@ function createDelivery(port, config) {
   function flush() {
     if (disposed) return;
     clearMergeTimer();
-    scheduleFlush(0);
+    scheduleFlush();
   }
   function depth() {
     let n = 0;
@@ -616,13 +528,12 @@ function createDelivery(port, config) {
       const idx = active.indexOf(e);
       if (idx !== -1) active.splice(idx, 1);
       e.state = "queued";
-      e.sendAttempts = 0;
       e.updatedAt = now();
       e.settledAt = void 0;
     }
     active.unshift(...found);
     notifyChange();
-    scheduleFlush(0);
+    scheduleFlush();
     return found.length;
   }
   function cancel(id) {
@@ -651,17 +562,34 @@ function createDelivery(port, config) {
     finalizeEntry(e, "cancelled");
     return { kind: "cancelled", entry: snapshot(e) };
   }
+  function failInFlight(reason) {
+    if (disposed) return 0;
+    const ts = now();
+    let count = 0;
+    for (const e of active) {
+      if (e.state !== "in-flight") continue;
+      const batchIdx = inflightBatch.indexOf(e);
+      if (batchIdx !== -1) inflightBatch.splice(batchIdx, 1);
+      e.state = "failed";
+      e.updatedAt = ts;
+      e.settledAt = ts;
+      count++;
+      callOnSettled(e.msg, "rejected");
+    }
+    if (count > 0) {
+      warn(`failInFlight: ${count} in-flight entry(ies) marked failed (${reason})`);
+      notifyChange();
+    }
+    return count;
+  }
   function drain() {
     if (disposed) return [];
     clearMergeTimer();
-    clearBackoffTimer();
-    clearHangTimer();
     const drained = active.slice();
     active.length = 0;
     activeIndex.clear();
     inflightBatch = [];
     inFlight = false;
-    sendAttempts = 0;
     const ts = now();
     const result = drained.map((e) => {
       tombstones.set(e.id, { id: e.id, state: "cancelled", lane: e.lane, settledAt: ts });
@@ -671,16 +599,12 @@ function createDelivery(port, config) {
       w.reject(new DeliveryReclaimError("drained"));
     }
     checkedPending.length = 0;
-    stopWatchdog();
     if (drained.length > 0) notifyChange();
     return result;
   }
   function dispose() {
     disposed = true;
     clearMergeTimer();
-    clearBackoffTimer();
-    clearHangTimer();
-    stopWatchdog();
     teardownSettledSub();
     active.length = 0;
     activeIndex.clear();
@@ -695,7 +619,7 @@ function createDelivery(port, config) {
     checkedPending.length = 0;
     dedupSet?.clear();
   }
-  return { send, sendChecked, flush, depth, entriesFull, projection, onChange, confirmDelivered, confirmAccepted, requeue, cancel, drain, dispose };
+  return { send, sendChecked, flush, depth, entriesFull, projection, onChange, confirmDelivered, confirmAccepted, requeue, cancel, failInFlight, drain, dispose };
 }
 export {
   DeliveryReclaimError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/session-delivery",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Session message delivery kernel: zero-pi-dependency strategy layer for queueing, batching, dedup, and gated flush of messages into pi sessions",
   "main": "dist/index.mjs",
   "module": "dist/index.mjs",