@capybara-hq/kernel 0.1.0-rc.1 → 0.1.0-rc.2

package/dist/channels/inbound.js

@@ -1,11 +1,31 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 import { randomUUID } from "node:crypto";
+import { Inject, Injectable } from "@nestjs/common";
+import { ConversationsService } from "../conversations/conversations.service.js";
 import { ApiError } from "../errors.js";
+import { IdentityBinding } from "../identity/binding.js";
+import { ExternalIdentities } from "../identity/external.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { LockService } from "../infra/lock/lock.service.js";
+import { KERNEL_LOGGER, REDIS } from "../infra/tokens.js";
+import { DirectorySync } from "../orgs/directory-sync.js";
 import { readOrgSettings } from "../orgs/settings.service.js";
 import { parseSlashCommand } from "../skills/invoke.js";
+import { ApprovalsService } from "../tools/approvals.service.js";
+import { QuestionsService } from "../tools/questions.service.js";
 import { ChannelCardActions } from "./actions.js";
-import { idempotencyKey, inboundJobId } from "./outbound.js";
+import { ChannelConnections } from "./connections.service.js";
+import { ChannelJobs, idempotencyKey, inboundJobId } from "./jobs.js";
 import { phrase } from "./phrases.js";
-import { archiveThread, ensureAnonymousGuest, findThread, insertThread, threadKeyOf, } from "./threads.js";
+import { AnonymousGuests, archiveThread, findThread, insertThread, threadKeyOf, } from "./threads.js";
 /** 入站消息去重键的保留时长（秒）：平台在这段时间内重投同一条消息只处理一次。 */
 export const MESSAGE_DEDUPE_TTL_SECONDS = 86_400;
 /** Dedupe key states: the enqueue is running (`pending`) or has succeeded (`done`). */
@@ -13,11 +33,6 @@ export const DEDUPE_PENDING = "pending";
 export const DEDUPE_DONE = "done";
 /** A `pending` key outlives a crashed enqueuer only this long, then redeliveries enqueue again. */
 export const DEDUPE_PENDING_TTL_SECONDS = 60;
-/** Deletes KEYS[1] only while it still holds ARGV[1] (a failed enqueue must not drop `done`). */
-const DEL_IF_PENDING = `if redis.call("GET", KEYS[1]) == ARGV[1] then
-  return redis.call("DEL", KEYS[1])
-end
-return 0`;
 /** 入站消息去重键（Redis 键，不是队列名 / job id，可以含 `:`）。 */
 export const messageDedupeKey = (connectionId, messageId) => `capk:channel-msg:${connectionId}:${messageId}`;
 /** 带平台事件 id 的卡片点击的去重键（Ruling A26，Redis 键，可以含 `:`）。 */
@@ -47,17 +62,47 @@ export const actionDedupeKey = (connectionId, eventId) => `capk:channel-act:${co
  * 边界（已接受）：同一 chat 的连续消息由不同任务并发处理，极少数情况下写入顺序可能与平台顺序不同；
  * 处理在写入用户消息之后失败而重试时，固定话术 / 卡片回复可能再发一次。
  */
-export class ChannelInbound {
-    deps;
+let ChannelInbound = class ChannelInbound {
+    kdb;
+    redis;
+    locks;
+    connections;
+    conversations;
+    external;
+    binding;
+    directorySync;
+    jobs;
+    guests;
+    log;
     actions;
-    constructor(deps) {
-        this.deps = deps;
+    constructor(kdb, redis, 
+    /** The two-state dedupe markers (`lease` / `holderOf` / `releaseIf`; keys unchanged). */
+    locks, connections, conversations, external, binding, 
+    /** 通讯录同步的投递（按 (组织, 插件) 每分钟去重的维护队列任务）。 */
+    directorySync, 
+    /** The channel queue: inbound jobs (`onEvent` only dedupes and enqueues) and deliveries. */
+    jobs, 
+    /** 卡片操作：审批决定与提问回答（授权由这两个服务按点击者映射到的账号判定）。 */
+    approvals, questions, guests, log) {
+        this.kdb = kdb;
+        this.redis = redis;
+        this.locks = locks;
+        this.connections = connections;
+        this.conversations = conversations;
+        this.external = external;
+        this.binding = binding;
+        this.directorySync = directorySync;
+        this.jobs = jobs;
+        this.guests = guests;
+        this.log = log;
         this.actions = new ChannelCardActions({
-            db: deps.db,
-            connections: deps.connections,
-            approvals: deps.approvals,
-            questions: deps.questions,
-            outbound: deps.outbound,
+            get db() {
+                return kdb.db;
+            },
+            connections,
+            approvals,
+            questions,
+            outbound: jobs,
             resolveSpeaker: (...args) => this.resolveSpeaker(...args),
         });
     }
@@ -70,7 +115,7 @@ export class ChannelInbound {
         if (e.type === "card_action") {
             if (e.eventId === undefined) {
                 // 平台没给事件 id：无法识别重投，每次都处理（重复的审批 / 回答由服务回「已处理」）
-                await this.deps.queue.enqueueInbound(connectionId, e, `inbound-${connectionId}-a${randomUUID()}`);
+                await this.jobs.enqueueInbound(connectionId, e, `inbound-${connectionId}-a${randomUUID()}`);
                 return;
             }
             return this.dedupeAndEnqueue(connectionId, e, actionDedupeKey(connectionId, e.eventId), inboundJobId(connectionId, `act:${e.eventId}`));
@@ -89,10 +134,9 @@ export class ChannelInbound {
      *   not create a second run; it means a redelivery is never acked before the job is really queued.
      */
     async dedupeAndEnqueue(connectionId, e, key, jobId) {
-        const { redis, queue } = this.deps;
-        const fresh = await redis.set(key, DEDUPE_PENDING, "EX", DEDUPE_PENDING_TTL_SECONDS, "NX");
-        if (fresh !== "OK") {
-            const state = await redis.get(key);
+        const fresh = await this.locks.lease(key, DEDUPE_PENDING, DEDUPE_PENDING_TTL_SECONDS * 1000);
+        if (!fresh) {
+            const state = await this.locks.holderOf(key);
             // Ack only a known-queued event ("1" = key from the pre-two-state code during a rolling
             // upgrade); pending, or a key that vanished meanwhile (failed attempt, TTL), enqueues again
             if (state === DEDUPE_DONE || state === "1")
@@ -101,20 +145,21 @@ export class ChannelInbound {
         // Accepted edge: if the completed-job cap evicts the original job within the pending window,
         // the re-add below runs the event twice (a duplicate run, never a loss)
         try {
-            await queue.enqueueInbound(connectionId, e, jobId);
+            await this.jobs.enqueueInbound(connectionId, e, jobId);
         }
         catch (err) {
-            await redis.eval(DEL_IF_PENDING, 1, key, DEDUPE_PENDING).catch(() => { });
+            // a failed enqueue must not drop `done` (compare-and-delete)
+            await this.locks.releaseIf(key, DEDUPE_PENDING).catch(() => { });
             throw err;
         }
-        await redis.set(key, DEDUPE_DONE, "EX", MESSAGE_DEDUPE_TTL_SECONDS);
+        await this.redis.set(key, DEDUPE_DONE, "EX", MESSAGE_DEDUPE_TTL_SECONDS);
     }
     /** 入站任务的处理（worker 上执行；失败抛错由队列重试）。 */
     async handle(connectionId, e) {
         if (e.type === "directory_changed") {
-            const row = await this.deps.connections.row(connectionId);
+            const row = await this.connections.row(connectionId);
             if (row?.status === "active" && row.pluginEnabled) {
-                await this.deps.directorySync.enqueue(row.orgId, row.plugin);
+                await this.directorySync.enqueue(row.orgId, row.plugin);
             }
             return;
         }
@@ -125,7 +170,8 @@ export class ChannelInbound {
         await this.message(connectionId, e);
     }
     async message(connectionId, e) {
-        const { db, connections } = this.deps;
+        const db = this.kdb.db;
+        const connections = this.connections;
         const row = await connections.row(connectionId);
         // 连接停用、组织已删除或插件在该组织停用（停用广播与长连接断开之间仍可能有事件到达）：什么都不做
         if (row?.status !== "active" || !row.pluginEnabled)
@@ -161,7 +207,7 @@ export class ChannelInbound {
         if (conversationId === undefined) {
             let created;
             try {
-                created = (await this.deps.conversations.create(row.orgId, accountId, row.agentId)).id;
+                created = (await this.conversations.create(row.orgId, accountId, row.agentId)).id;
             }
             catch (err) {
                 if (err instanceof ApiError && err.code === "agent.not_found") {
@@ -190,7 +236,7 @@ export class ChannelInbound {
             // best-effort (batch 5 review m4): a failed note must not fail the job before the thread
             // is bound for the agent's reply below
             if (posted.skillNotRun) {
-                await reply("skillNotRun").catch((err) => this.deps.log.warn("cannot send the skill-not-run note", {
+                await reply("skillNotRun").catch((err) => this.log.warn("cannot send the skill-not-run note", {
                     connectionId,
                     messageId: e.messageId,
                     err,
@@ -219,7 +265,7 @@ export class ChannelInbound {
             updated_at: new Date(),
         }))
             .execute();
-        await this.deps.outbound.enqueue(conversationId);
+        await this.jobs.enqueue(conversationId);
     }
     /**
      * Posts the person's message: `/name args` as a skill invocation when the kernel accepts it, else
@@ -233,7 +279,11 @@ export class ChannelInbound {
         let skillNotRun = false;
         if (cmd !== null) {
             try {
-                const event = await this.deps.conversations.postUserMessage(orgId, conversationId, accountId, { ...input, text: cmd.args, skill: { name: cmd.name } });
+                const event = await this.conversations.postUserMessage(orgId, conversationId, accountId, {
+                    ...input,
+                    text: cmd.args,
+                    skill: { name: cmd.name },
+                });
                 return { event, skillNotRun };
             }
             catch (err) {
@@ -243,7 +293,7 @@ export class ChannelInbound {
                 }
                 if (err.code === "validation_failed") {
                     skillNotRun = true;
-                    this.deps.log.info("IM skill invocation posted as text", {
+                    this.log.info("IM skill invocation posted as text", {
                         conversationId,
                         skill: cmd.name,
                         reason: err.message,
@@ -251,7 +301,7 @@ export class ChannelInbound {
                 }
             }
         }
-        const event = await this.deps.conversations.postUserMessage(orgId, conversationId, accountId, input);
+        const event = await this.conversations.postUserMessage(orgId, conversationId, accountId, input);
         return { event, skillNotRun };
     }
     /**
@@ -260,9 +310,8 @@ export class ChannelInbound {
      * `threadAccount` 为话题行记的账号（匿名访客为 null）。
      */
     async resolveSpeaker(connectionId, row, sender, isGroup, locale, reply) {
-        const { db } = this.deps;
         const source = `${row.plugin}:${sender.tenantId}`;
-        const bound = await this.deps.external.findAccount(source, sender.externalId);
+        const bound = await this.external.findAccount(source, sender.externalId);
         if (bound !== undefined && (await this.isActiveMember(row.orgId, bound))) {
             return { accountId: bound, threadAccount: bound };
         }
@@ -273,7 +322,7 @@ export class ChannelInbound {
                 await reply("anonymousNotAllowed");
                 return undefined;
             }
-            return { accountId: await ensureAnonymousGuest(db, row.orgId), threadAccount: null };
+            return { accountId: await this.guests.ensure(row.orgId), threadAccount: null };
         }
         if (bound !== undefined) {
             await reply("notMember");
@@ -285,7 +334,7 @@ export class ChannelInbound {
         }
         let url;
         try {
-            url = await this.deps.binding.createBindToken({
+            url = await this.binding.createBindToken({
                 connectionId,
                 identity: {
                     source,
@@ -298,7 +347,7 @@ export class ChannelInbound {
             });
         }
         catch (err) {
-            this.deps.log.warn("cannot create channel bind link", { connectionId, err });
+            this.log.warn("cannot create channel bind link", { connectionId, err });
             await reply("bindUnavailable");
             return undefined;
         }
@@ -307,7 +356,7 @@ export class ChannelInbound {
     }
     /** 账号是该组织成员且账号未停用。 */
     async isActiveMember(orgId, accountId) {
-        const r = await this.deps.db
+        const r = await this.kdb
             .selectFrom("memberships")
             .innerJoin("accounts", "accounts.id", "memberships.account_id")
             .select("memberships.role")
@@ -319,7 +368,7 @@ export class ChannelInbound {
     }
     /** 连接绑定的 agent 未删除且可见范围为「全组织」（匿名访客只能用这种 agent）。 */
     async agentVisibleToOrg(orgId, agentId) {
-        const r = await this.deps.db
+        const r = await this.kdb
             .selectFrom("agents")
             .select("id")
             .where("id", "=", agentId)
@@ -329,4 +378,21 @@ export class ChannelInbound {
             .executeTakeFirst();
         return r !== undefined;
     }
-}
+};
+ChannelInbound = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(REDIS)),
+    __param(2, Inject(LockService)),
+    __param(3, Inject(ChannelConnections)),
+    __param(4, Inject(ConversationsService)),
+    __param(5, Inject(ExternalIdentities)),
+    __param(6, Inject(IdentityBinding)),
+    __param(7, Inject(DirectorySync)),
+    __param(8, Inject(ChannelJobs)),
+    __param(9, Inject(ApprovalsService)),
+    __param(10, Inject(QuestionsService)),
+    __param(11, Inject(AnonymousGuests)),
+    __param(12, Inject(KERNEL_LOGGER))
+], ChannelInbound);
+export { ChannelInbound };

package/dist/channels/job-ids.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The channel gateway check's job name and the maintenance job scheduler id it had before it
+ * became a `@LockedCron` job: an upgraded deployment still has the
+ * scheduler in Redis, so the worker removes it at start (`RETIRED_SCHEDULER_IDS`). A leaf module:
+ * the maintenance worker imports it without the channel providers.
+ */
+/** The gateway check's job name (`@LockedCron`). */
+export declare const GATEWAY_CHECK_JOB = "channel-gateway-check";
+/** The gateway check's old scheduler (every minute). */
+export declare const GATEWAY_CHECK_SCHEDULER_ID = "channel-gateway-check-every";

package/dist/channels/job-ids.js

@@ -0,0 +1,10 @@
+/**
+ * The channel gateway check's job name and the maintenance job scheduler id it had before it
+ * became a `@LockedCron` job: an upgraded deployment still has the
+ * scheduler in Redis, so the worker removes it at start (`RETIRED_SCHEDULER_IDS`). A leaf module:
+ * the maintenance worker imports it without the channel providers.
+ */
+/** The gateway check's job name (`@LockedCron`). */
+export const GATEWAY_CHECK_JOB = "channel-gateway-check";
+/** The gateway check's old scheduler (every minute). */
+export const GATEWAY_CHECK_SCHEDULER_ID = "channel-gateway-check-every";

package/dist/channels/jobs.d.ts

@@ -0,0 +1,85 @@
+import type { InboundEvent, Logger } from "@capybara-hq/plugin-sdk";
+import { type OnApplicationShutdown } from "@nestjs/common";
+import type { Queue } from "bullmq";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { KernelEvents } from "../infra/events/kernel-events.js";
+/** 渠道队列（出站投递与入站任务，不含 `:`），只在 worker 角色上消费。 */
+export declare const CHANNEL_QUEUE_NAME = "cap-kernel-channels";
+/** 投递任务名。 */
+export declare const DELIVER_JOB = "deliver";
+/** 投递任务 id（不含 `:`）：同一会话、同一日志位置只排一个任务。 */
+export declare const deliverJobId: (conversationId: string, seq: number) => string;
+/**
+ * 结束后复核排的任务 id：每次唯一（带随机后缀，不含 `:`）。不能复用 `deliver-<会话>-<seq>`——同 id 的任务
+ * 可能正因锁被占而即将直接结束，BullMQ 会把新任务去重进它，于是没人投递。
+ */
+export declare const followUpJobId: (conversationId: string, seq: number) => string;
+/**
+ * 发给插件的幂等键（Ruling A15）：把逻辑键（如 `<会话>-<seq>`）做 sha256，取 base64url 的前 32 个字符——
+ * 稳定、只含 `[A-Za-z0-9_-]`，满足常见平台的长度限制。
+ */
+export declare function idempotencyKey(raw: string): string;
+/** 可重试失败（限流、5xx、网络、超时）的总尝试次数。 */
+export declare const DELIVER_ATTEMPTS = 8;
+export interface DeliverJobData {
+    conversationId: string;
+}
+/** 入站任务（Ruling A21）：插件 `onEvent` 收到的事件，原样排进队列由 worker 处理。 */
+export interface InboundJobData {
+    connectionId: string;
+    event: InboundEvent;
+}
+export type ChannelJobData = DeliverJobData | InboundJobData;
+/** 入站任务名。 */
+export declare const INBOUND_JOB = "inbound";
+/**
+ * BullMQ 优先级（数字越小越先）：入站任务先于出站投递任务——投递任务可能占着并发槽等输出，
+ * 用户发来的消息不能排在它们后面。
+ */
+export declare const INBOUND_PRIORITY = 1;
+export declare const DELIVER_PRIORITY = 10;
+/** 入站任务的总尝试次数（处理失败由 BullMQ 指数退避重试：1s、2s、4s、8s）。 */
+export declare const INBOUND_ATTEMPTS = 5;
+/**
+ * 入站消息的任务 id（不含 `:`）：`inbound-<连接>-<sha256(消息 id) 的 base64url 前 22 位>`。同一条消息只排一个任务
+ * （已完成的任务保留一段时间，期间重复入队被 BullMQ 忽略）。
+ */
+export declare const inboundJobId: (connectionId: string, messageId: string) => string;
+/**
+ * The producer side of the channel queue `cap-kernel-channels` (any role): delivery jobs for a
+ * conversation with an IM target, inbound jobs (Ruling A21), and the catch-up of a connection that
+ * can deliver again. Its consumer is {@link ChannelOutbound} through the `@Processor` of the worker
+ * role. Delivery jobs follow the kernel's domain events (spec §3b): every published log advance
+ * (`conversation.event-appended`), a run starting here (`run.started`), a stopped wait
+ * (`run.wait-stopped`), a decided approval and an answered question (their cards change). Each is
+ * lost-tolerant: the next append enqueues again, and a finished delivery job re-checks the log.
+ */
+export declare class ChannelJobs implements OnApplicationShutdown {
+    private readonly db;
+    private readonly queue;
+    private readonly log;
+    /** Stopped (the stop's channel-outbound phase): enqueues do nothing, inbound enqueues throw. */
+    private closed;
+    private readonly unsubscribe;
+    constructor(db: KernelDb, queue: Queue<ChannelJobData>, events: Pick<KernelEvents, "on">, log: Pick<Logger, "warn" | "error">);
+    /** Unsubscribes after the stop phases: events emitted while they drain are still handled. */
+    onApplicationShutdown(): void;
+    /** 会话有 IM 投递目标时排一个出站任务，不等入队完成；失败只记日志。 */
+    private enqueueSoon;
+    /** 会话有 IM 投递目标时投递一个出站任务（同一日志位置重复调用只排一个）；已关闭时什么都不做。 */
+    enqueue(conversationId: string, opts?: {
+        followUp?: boolean;
+    }): Promise<void>;
+    /**
+     * 排一个入站任务（Ruling A21，同一队列 `cap-kernel-channels`）：处理失败按 {@link INBOUND_ATTEMPTS} 次指数退避重试。
+     * 已关闭时抛错（调用方据此让插件不确认、由平台重投）。
+     */
+    enqueueInbound(connectionId: string, event: InboundEvent, jobId: string): Promise<void>;
+    /**
+     * 连接重新可投递（轮换了凭据 / 重新启用）：给该连接投递进度落后于会话日志的会话各排一个出站任务，
+     * 补投停用或凭据失效期间落下的内容（不必等下一条消息）。
+     */
+    resumeConnection(connectionId: string): Promise<void>;
+    /** No more jobs from this process (the stop's channel-outbound phase). Idempotent. */
+    close(): void;
+}

package/dist/channels/jobs.js

@@ -0,0 +1,157 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { createHash, randomUUID } from "node:crypto";
+import { getQueueToken } from "@nestjs/bullmq";
+import { Inject, Injectable } from "@nestjs/common";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { KernelEvents } from "../infra/events/kernel-events.js";
+import { KERNEL_LOGGER } from "../infra/tokens.js";
+/** 渠道队列（出站投递与入站任务，不含 `:`），只在 worker 角色上消费。 */
+export const CHANNEL_QUEUE_NAME = "cap-kernel-channels";
+/** 投递任务名。 */
+export const DELIVER_JOB = "deliver";
+/** 投递任务 id（不含 `:`）：同一会话、同一日志位置只排一个任务。 */
+export const deliverJobId = (conversationId, seq) => `deliver-${conversationId}-${seq}`;
+/**
+ * 结束后复核排的任务 id：每次唯一（带随机后缀，不含 `:`）。不能复用 `deliver-<会话>-<seq>`——同 id 的任务
+ * 可能正因锁被占而即将直接结束，BullMQ 会把新任务去重进它，于是没人投递。
+ */
+export const followUpJobId = (conversationId, seq) => `deliver-${conversationId}-${seq}-f${randomUUID().slice(0, 8)}`;
+/**
+ * 发给插件的幂等键（Ruling A15）：把逻辑键（如 `<会话>-<seq>`）做 sha256，取 base64url 的前 32 个字符——
+ * 稳定、只含 `[A-Za-z0-9_-]`，满足常见平台的长度限制。
+ */
+export function idempotencyKey(raw) {
+    return createHash("sha256").update(raw).digest("base64url").slice(0, 32);
+}
+/** 可重试失败（限流、5xx、网络、超时）的总尝试次数。 */
+export const DELIVER_ATTEMPTS = 8;
+/** 入站任务名。 */
+export const INBOUND_JOB = "inbound";
+/**
+ * BullMQ 优先级（数字越小越先）：入站任务先于出站投递任务——投递任务可能占着并发槽等输出，
+ * 用户发来的消息不能排在它们后面。
+ */
+export const INBOUND_PRIORITY = 1;
+export const DELIVER_PRIORITY = 10;
+/** 入站任务的总尝试次数（处理失败由 BullMQ 指数退避重试：1s、2s、4s、8s）。 */
+export const INBOUND_ATTEMPTS = 5;
+const INBOUND_BACKOFF_MS = 1000;
+/**
+ * 入站消息的任务 id（不含 `:`）：`inbound-<连接>-<sha256(消息 id) 的 base64url 前 22 位>`。同一条消息只排一个任务
+ * （已完成的任务保留一段时间，期间重复入队被 BullMQ 忽略）。
+ */
+export const inboundJobId = (connectionId, messageId) => `inbound-${connectionId}-${createHash("sha256").update(messageId).digest("base64url").slice(0, 22)}`;
+/**
+ * The producer side of the channel queue `cap-kernel-channels` (any role): delivery jobs for a
+ * conversation with an IM target, inbound jobs (Ruling A21), and the catch-up of a connection that
+ * can deliver again. Its consumer is {@link ChannelOutbound} through the `@Processor` of the worker
+ * role. Delivery jobs follow the kernel's domain events (spec §3b): every published log advance
+ * (`conversation.event-appended`), a run starting here (`run.started`), a stopped wait
+ * (`run.wait-stopped`), a decided approval and an answered question (their cards change). Each is
+ * lost-tolerant: the next append enqueues again, and a finished delivery job re-checks the log.
+ */
+let ChannelJobs = class ChannelJobs {
+    db;
+    queue;
+    log;
+    /** Stopped (the stop's channel-outbound phase): enqueues do nothing, inbound enqueues throw. */
+    closed = false;
+    unsubscribe;
+    constructor(db, queue, events, log) {
+        this.db = db;
+        this.queue = queue;
+        this.log = log;
+        queue.on("error", (err) => this.log.error("channel outbound queue error", { err }));
+        const soon = ({ conversationId }) => this.enqueueSoon(conversationId);
+        this.unsubscribe = [
+            events.on("conversation.event-appended", soon),
+            events.on("run.started", soon),
+            events.on("run.wait-stopped", soon),
+            events.on("approval.decided", soon),
+            events.on("question.answered", soon),
+        ];
+    }
+    /** Unsubscribes after the stop phases: events emitted while they drain are still handled. */
+    onApplicationShutdown() {
+        for (const off of this.unsubscribe)
+            off();
+    }
+    /** 会话有 IM 投递目标时排一个出站任务，不等入队完成；失败只记日志。 */
+    enqueueSoon(conversationId) {
+        this.enqueue(conversationId).catch((err) => this.log.warn("cannot enqueue channel delivery", { conversationId, err }));
+    }
+    /** 会话有 IM 投递目标时投递一个出站任务（同一日志位置重复调用只排一个）；已关闭时什么都不做。 */
+    async enqueue(conversationId, opts = {}) {
+        if (this.closed)
+            return;
+        const row = await this.db
+            .selectFrom("channel_deliveries")
+            .innerJoin("conversations", "conversations.id", "channel_deliveries.conversation_id")
+            .select("conversations.last_seq")
+            .where("channel_deliveries.conversation_id", "=", conversationId)
+            .executeTakeFirst();
+        if (!row || this.closed)
+            return;
+        await this.queue.add(DELIVER_JOB, { conversationId }, {
+            jobId: opts.followUp
+                ? followUpJobId(conversationId, Number(row.last_seq))
+                : deliverJobId(conversationId, Number(row.last_seq)),
+            attempts: DELIVER_ATTEMPTS,
+            backoff: { type: "deliver" },
+            priority: DELIVER_PRIORITY,
+            removeOnComplete: true,
+            removeOnFail: true,
+        });
+    }
+    /**
+     * 排一个入站任务（Ruling A21，同一队列 `cap-kernel-channels`）：处理失败按 {@link INBOUND_ATTEMPTS} 次指数退避重试。
+     * 已关闭时抛错（调用方据此让插件不确认、由平台重投）。
+     */
+    async enqueueInbound(connectionId, event, jobId) {
+        if (this.closed)
+            throw new Error("channel outbound queue is closed");
+        await this.queue.add(INBOUND_JOB, { connectionId, event }, {
+            jobId,
+            attempts: INBOUND_ATTEMPTS,
+            priority: INBOUND_PRIORITY,
+            backoff: { type: "exponential", delay: INBOUND_BACKOFF_MS },
+            removeOnComplete: { age: 3600, count: 1000 },
+            removeOnFail: { age: 86_400 },
+        });
+    }
+    /**
+     * 连接重新可投递（轮换了凭据 / 重新启用）：给该连接投递进度落后于会话日志的会话各排一个出站任务，
+     * 补投停用或凭据失效期间落下的内容（不必等下一条消息）。
+     */
+    async resumeConnection(connectionId) {
+        const rows = await this.db
+            .selectFrom("channel_deliveries")
+            .innerJoin("conversations", "conversations.id", "channel_deliveries.conversation_id")
+            .select("channel_deliveries.conversation_id")
+            .where("channel_deliveries.connection_id", "=", connectionId)
+            .whereRef("channel_deliveries.last_seq", "<", "conversations.last_seq")
+            .execute();
+        for (const r of rows)
+            await this.enqueue(r.conversation_id, { followUp: true });
+    }
+    /** No more jobs from this process (the stop's channel-outbound phase). Idempotent. */
+    close() {
+        this.closed = true;
+    }
+};
+ChannelJobs = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(getQueueToken(CHANNEL_QUEUE_NAME))),
+    __param(2, Inject(KernelEvents)),
+    __param(3, Inject(KERNEL_LOGGER))
+], ChannelJobs);
+export { ChannelJobs };