@capybara-hq/kernel 0.1.0-rc.0 → 0.1.0-rc.10

package/dist/conversations/message-context.d.ts

@@ -0,0 +1,79 @@
+import type { KernelSchemaDb } from "../db/kernel-schema.js";
+import type { EventPayload } from "./events.js";
+/** The name of an anonymous IM guest whose IM profile gives none. */
+export declare const ANONYMOUS_SENDER_NAME = "Anonymous guest";
+/** What the browser sent with a message (run context spec §3.4); both optional. */
+export interface BrowserContext {
+    timeZone?: string | undefined;
+    locale?: "zh" | "en" | undefined;
+}
+/**
+ * What an IM platform gave for the sender of a message (channel@1 `sender.timeZone` /
+ * `sender.locale`, normalized by {@link imSenderContext}); both optional.
+ */
+export interface ImSenderContext {
+    timeZone?: string | undefined;
+    locale?: "zh" | "en" | undefined;
+}
+/**
+ * An IM sender's language tag as a run-context language: `zh` and `zh-*` / `zh_*` (any case) are
+ * Chinese, any other non-empty tag English; not a string or blank: undefined.
+ */
+export declare function imLocale(tag: unknown): "zh" | "en" | undefined;
+/**
+ * The time zone and language an inbound channel event's sender carries (values from an extension,
+ * so checked here): a time zone the runtime knows, the language normalized by {@link imLocale}.
+ */
+export declare function imSenderContext(sender: {
+    timeZone?: unknown;
+    locale?: unknown;
+}): ImSenderContext;
+/** How many of the person's latest web conversations {@link latestWebLocale} looks at. */
+export declare const WEB_LOCALE_CONVERSATIONS = 20;
+/**
+ * The UI language of the person's most recent web message in the org (run context spec §3.4):
+ * the latest `user_message` they wrote in each of their {@link WEB_LOCALE_CONVERSATIONS} most
+ * recently updated chat conversations that are not IM threads, the newest one with a recorded
+ * `locale`. Bounded and index-friendly: `conversations_account_idx`, then one backwards primary-key
+ * walk per conversation that stops at its latest user message. Undefined when none.
+ */
+export declare function latestWebLocale(t: KernelSchemaDb, orgId: string, accountId: string): Promise<"zh" | "en" | undefined>;
+/**
+ * The language of kernel-generated IM text for one person (run context spec §3.4, maintainer
+ * decision 2026-11-08: in IM, language is per person): `im` (what the IM platform gave for the
+ * sender, already normalized by {@link imLocale}), else the UI language of the person's most recent
+ * web message in the org ({@link latestWebLocale}; no account, e.g. a speaker not resolved yet or
+ * the shared anonymous guest: skipped), else the org's `locale`. Read from PG on every call: no
+ * cache, so every replica answers the same.
+ */
+export declare function recipientLocale(t: KernelSchemaDb, input: {
+    orgId: string;
+    accountId?: string | null | undefined;
+    im?: "zh" | "en" | undefined;
+}): Promise<"zh" | "en">;
+/** The `user_message` fields {@link readMessageContext} fills. */
+export type MessageContext = Pick<EventPayload<"user_message">, "sender" | "timeZone" | "locale">;
+/**
+ * Who wrote a message and in which time zone and language (run context spec §3.2, §3.4), read in
+ * the message's transaction (`t`):
+ * - `sender`: the account's display name and org role at send time; the org's anonymous guest
+ *   account (`org_anonymous_accounts`) is `{ name: <senderName, else "Anonymous guest">, role:
+ *   "guest", anonymous: true }`. Names are sanitised; an empty one leaves `sender` out.
+ * - `timeZone`: what the IM platform gave for the sender (`im`, when valid), else the account's
+ *   setting, else the browser's (when valid), else the org default, else UTC. The anonymous guest
+ *   account has no setting of its own, so it gets the IM value or the org default.
+ * - `locale`: the IM platform's value, else the browser's UI language, else the UI language of the
+ *   person's most recent web message in the org ({@link latestWebLocale}; not for the shared
+ *   anonymous guest account), else the org's `locale`.
+ *
+ * The values used are recorded on the message, so the run context is derived from the log.
+ */
+export declare function readMessageContext(t: KernelSchemaDb, input: {
+    orgId: string;
+    accountId: string;
+    /** An anonymous IM guest's IM profile name. */
+    senderName?: string | undefined;
+    browser?: BrowserContext | undefined;
+    /** An IM message: what the platform gave for the sender (maintainer decision 2026-11-08). */
+    im?: ImSenderContext | undefined;
+}): Promise<MessageContext>;

package/dist/conversations/message-context.js

@@ -0,0 +1,145 @@
+import { sql } from "kysely";
+import { readOrgSettings } from "../orgs/settings.service.js";
+import { sanitizeSenderName } from "../runtime/context/run-context.js";
+import { isTimeZone } from "../time-zone.js";
+/** The name of an anonymous IM guest whose IM profile gives none. */
+export const ANONYMOUS_SENDER_NAME = "Anonymous guest";
+/**
+ * An IM sender's language tag as a run-context language: `zh` and `zh-*` / `zh_*` (any case) are
+ * Chinese, any other non-empty tag English; not a string or blank: undefined.
+ */
+export function imLocale(tag) {
+    if (typeof tag !== "string")
+        return undefined;
+    const t = tag.trim().toLowerCase();
+    if (t === "" || t.length > 64)
+        return undefined;
+    return t === "zh" || t.startsWith("zh-") || t.startsWith("zh_") ? "zh" : "en";
+}
+/**
+ * The time zone and language an inbound channel event's sender carries (values from an extension,
+ * so checked here): a time zone the runtime knows, the language normalized by {@link imLocale}.
+ */
+export function imSenderContext(sender) {
+    const tz = sender.timeZone;
+    const locale = imLocale(sender.locale);
+    return {
+        ...(typeof tz === "string" && isTimeZone(tz) && { timeZone: tz }),
+        ...(locale !== undefined && { locale }),
+    };
+}
+/** How many of the person's latest web conversations {@link latestWebLocale} looks at. */
+export const WEB_LOCALE_CONVERSATIONS = 20;
+/**
+ * The UI language of the person's most recent web message in the org (run context spec §3.4):
+ * the latest `user_message` they wrote in each of their {@link WEB_LOCALE_CONVERSATIONS} most
+ * recently updated chat conversations that are not IM threads, the newest one with a recorded
+ * `locale`. Bounded and index-friendly: `conversations_account_idx`, then one backwards primary-key
+ * walk per conversation that stops at its latest user message. Undefined when none.
+ */
+export async function latestWebLocale(t, orgId, accountId) {
+    const r = await sql `
+    SELECT m.locale FROM (
+      SELECT c.id FROM capybara.conversations c
+      WHERE c.org_id = ${orgId} AND c.account_id = ${accountId} AND c.kind = 'chat'
+        AND c.deleted_at IS NULL
+        AND NOT EXISTS (SELECT 1 FROM capybara.channel_threads th WHERE th.conversation_id = c.id)
+      ORDER BY c.updated_at DESC
+      LIMIT ${WEB_LOCALE_CONVERSATIONS}
+    ) c
+    CROSS JOIN LATERAL (
+      SELECT e.payload->>'locale' AS locale, e.created_at FROM capybara.conversation_events e
+      WHERE e.conversation_id = c.id AND e.type = 'user_message'
+        AND e.payload->>'authorAccountId' = ${accountId}
+      ORDER BY e.seq DESC
+      LIMIT 1
+    ) m
+    WHERE m.locale IN ('zh', 'en')
+    ORDER BY m.created_at DESC
+    LIMIT 1`.execute(t);
+    const locale = r.rows[0]?.locale;
+    return locale === "zh" || locale === "en" ? locale : undefined;
+}
+/**
+ * The language of kernel-generated IM text for one person (run context spec §3.4, maintainer
+ * decision 2026-11-08: in IM, language is per person): `im` (what the IM platform gave for the
+ * sender, already normalized by {@link imLocale}), else the UI language of the person's most recent
+ * web message in the org ({@link latestWebLocale}; no account, e.g. a speaker not resolved yet or
+ * the shared anonymous guest: skipped), else the org's `locale`. Read from PG on every call: no
+ * cache, so every replica answers the same.
+ */
+export async function recipientLocale(t, input) {
+    if (input.im !== undefined)
+        return input.im;
+    if (input.accountId) {
+        const web = await latestWebLocale(t, input.orgId, input.accountId);
+        if (web !== undefined)
+            return web;
+    }
+    return (await readOrgSettings(t, input.orgId)).locale;
+}
+/**
+ * Who wrote a message and in which time zone and language (run context spec §3.2, §3.4), read in
+ * the message's transaction (`t`):
+ * - `sender`: the account's display name and org role at send time; the org's anonymous guest
+ *   account (`org_anonymous_accounts`) is `{ name: <senderName, else "Anonymous guest">, role:
+ *   "guest", anonymous: true }`. Names are sanitised; an empty one leaves `sender` out.
+ * - `timeZone`: what the IM platform gave for the sender (`im`, when valid), else the account's
+ *   setting, else the browser's (when valid), else the org default, else UTC. The anonymous guest
+ *   account has no setting of its own, so it gets the IM value or the org default.
+ * - `locale`: the IM platform's value, else the browser's UI language, else the UI language of the
+ *   person's most recent web message in the org ({@link latestWebLocale}; not for the shared
+ *   anonymous guest account), else the org's `locale`.
+ *
+ * The values used are recorded on the message, so the run context is derived from the log.
+ */
+export async function readMessageContext(t, input) {
+    const row = await t
+        .selectFrom("accounts")
+        .leftJoin("memberships", (j) => j
+        .onRef("memberships.account_id", "=", "accounts.id")
+        .on("memberships.org_id", "=", input.orgId))
+        .leftJoin("org_anonymous_accounts as anon", (j) => j.onRef("anon.account_id", "=", "accounts.id").on("anon.org_id", "=", input.orgId))
+        .select([
+        "accounts.display_name",
+        "accounts.time_zone",
+        "memberships.role",
+        "anon.account_id as anonymous",
+    ])
+        .where("accounts.id", "=", input.accountId)
+        .executeTakeFirst();
+    const org = await readOrgSettings(t, input.orgId);
+    const anonymous = row?.anonymous !== null && row?.anonymous !== undefined;
+    let sender;
+    if (row !== undefined) {
+        const name = anonymous
+            ? sanitizeSenderName(input.senderName ?? "") || ANONYMOUS_SENDER_NAME
+            : sanitizeSenderName(row.display_name);
+        if (name !== "") {
+            sender = anonymous
+                ? { name, role: "guest", anonymous: true }
+                : { name, ...(row.role !== null && { role: row.role }) };
+        }
+    }
+    const im = input.im?.timeZone;
+    const own = row?.time_zone ?? null;
+    const browser = input.browser?.timeZone;
+    const timeZone = im !== undefined && isTimeZone(im)
+        ? im
+        : own !== null && isTimeZone(own)
+            ? own
+            : browser !== undefined && isTimeZone(browser)
+                ? browser
+                : (org.timeZone ?? "UTC");
+    const locale = input.im?.locale ??
+        input.browser?.locale ??
+        (row !== undefined && !anonymous
+            ? await latestWebLocale(t, input.orgId, input.accountId)
+            : undefined) ??
+        org.locale;
+    return {
+        ...(sender !== undefined && { sender }),
+        timeZone,
+        locale,
+    };
+}

package/dist/conversations/outputs-read.d.ts

@@ -1,3 +1,5 @@
+import { ToolOutputs } from "../tools/outputs.js";
+import { ConversationAccess } from "./access.js";
 /** 一次最多返回的字符数（也是默认值）：大存档按字符分页取。 */
 export declare const OUTPUT_PAGE_MAX_CHARS = 200000;
 export interface OutputPage {
@@ -10,23 +12,21 @@ export interface OutputPage {
     /** 下一页的 offset；已到末尾为 null。 */
     next: number | null;
 }
-export interface ConversationOutputsDeps {
-    /** 会话可见性（与会话 SSE 流同一判定：`ConversationsService.isAccessible`）。 */
-    isAccessible(orgId: string, conversationId: string, viewerAccountId: string): Promise<boolean>;
-    /** 读本会话未过期的存档（`ToolOutputs.load`）：不存在 / 过期 / 属于别的会话 → null。 */
-    load(scope: {
-        orgId: string;
-        conversationId: string;
-    }, id: string): Promise<string | null>;
-}
 /**
  * 网页读工具输出存档（运行标签看全文）：先按会话流的规则判定会话可见（不可见 → `conversation.not_found`），
  * 再只在这个会话的存档里找（别的会话 / 过期 → `conversation.output_not_found`）。
  * 按字符分页（单行可能就很长，按行分页不能保证页大小）；id 不是 UUID 时直接 404，不打到数据库。
  */
 export declare class ConversationOutputs {
-    private readonly d;
-    constructor(d: ConversationOutputsDeps);
+    /** 会话可见性（与会话 SSE 流同一判定）。 */
+    private readonly access;
+    /** 读本会话未过期的存档：不存在 / 过期 / 属于别的会话 → null。 */
+    private readonly outputs;
+    constructor(
+    /** 会话可见性（与会话 SSE 流同一判定）。 */
+    access: Pick<ConversationAccess, "isAccessible">, 
+    /** 读本会话未过期的存档：不存在 / 过期 / 属于别的会话 → null。 */
+    outputs: Pick<ToolOutputs, "load">);
     read(orgId: string, conversationId: string, viewerAccountId: string, outputId: string, page: {
         offset: number;
         limit: number;

package/dist/conversations/outputs-read.js

@@ -1,5 +1,17 @@
+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 { Inject, Injectable } from "@nestjs/common";
 import { ApiError } from "../errors.js";
+import { ToolOutputs } from "../tools/outputs.js";
 import { UUID_RE } from "../ui/registry.js";
+import { ConversationAccess } from "./access.js";
 /** 一次最多返回的字符数（也是默认值）：大存档按字符分页取。 */
 export const OUTPUT_PAGE_MAX_CHARS = 200_000;
 const conversationNotFound = () => new ApiError("conversation.not_found", "Conversation not found");
@@ -9,19 +21,25 @@ const outputNotFound = () => new ApiError("conversation.output_not_found", "Outp
  * 再只在这个会话的存档里找（别的会话 / 过期 → `conversation.output_not_found`）。
  * 按字符分页（单行可能就很长，按行分页不能保证页大小）；id 不是 UUID 时直接 404，不打到数据库。
  */
-export class ConversationOutputs {
-    d;
-    constructor(d) {
-        this.d = d;
+let ConversationOutputs = class ConversationOutputs {
+    access;
+    outputs;
+    constructor(
+    /** 会话可见性（与会话 SSE 流同一判定）。 */
+    access, 
+    /** 读本会话未过期的存档：不存在 / 过期 / 属于别的会话 → null。 */
+    outputs) {
+        this.access = access;
+        this.outputs = outputs;
     }
     async read(orgId, conversationId, viewerAccountId, outputId, page) {
         if (!UUID_RE.test(conversationId))
             throw conversationNotFound();
-        if (!(await this.d.isAccessible(orgId, conversationId, viewerAccountId)))
+        if (!(await this.access.isAccessible(orgId, conversationId, viewerAccountId)))
             throw conversationNotFound();
         if (!UUID_RE.test(outputId))
             throw outputNotFound();
-        const content = await this.d.load({ orgId, conversationId }, outputId);
+        const content = await this.outputs.load({ orgId, conversationId }, outputId);
         if (content === null)
             throw outputNotFound();
         const offset = Math.min(page.offset, content.length);
@@ -34,4 +52,10 @@ export class ConversationOutputs {
             next: end < content.length ? end : null,
         };
     }
-}
+};
+ConversationOutputs = __decorate([
+    Injectable(),
+    __param(0, Inject(ConversationAccess)),
+    __param(1, Inject(ToolOutputs))
+], ConversationOutputs);
+export { ConversationOutputs };

package/dist/conversations/queue.d.ts

@@ -1,9 +1,11 @@
-import { type Transaction } from "kysely";
 import { type ModelRef } from "../agents/definition.js";
-import type { KernelDatabase, KernelDb } from "../db/kernel-schema.js";
-import { type AttachmentRef, type ConversationsService, type RunControl } from "./conversations.service.js";
+import type { KernelSchemaDb } from "../db/kernel-schema.js";
+import { ApiError } from "../errors.js";
+import { type InvocationRecord, type RenderedInvocation } from "../skills/invoke.js";
+import type { AttachmentRef } from "./conversations.service.js";
 import { type AppendEvent, type EventLog } from "./event-log.js";
-import type { ConversationEvent } from "./events.js";
+import type { ConversationEvent, LogContentBlock } from "./events.js";
+import { type MessageContext } from "./message-context.js";
 /**
  * Queued messages (UI refresh B, spec §5.7): messages a person queued while a run was going. They
  * are conversation state in PG, not events: the model has not seen them, so they enter the log only
@@ -18,7 +20,16 @@ export declare const QUEUE_MAX_ITEMS = 20;
  * the conversation, or the head item's skill can no longer be invoked (phase D Task 9).
  */
 export type QueuePauseReason = "run_ended" | "author_cannot_send" | "skill_not_invocable";
-type KernelTrx = Transaction<KernelDatabase>;
+/**
+ * A queued skill invocation (phase D Task 9), stored in `conversation_queue.skill`: the name the
+ * person invoked (`<plugin>:<name>` or bare) and the `user_message.skill` record rendered with it.
+ */
+export interface QueuedSkill {
+    invokedAs: string;
+    record: InvocationRecord;
+}
+/** The caller's transaction handle (the module helpers below run inside it). */
+type KernelTrx = KernelSchemaDb;
 /** A queued message as the API returns it. */
 export interface QueueItem {
     id: string;
@@ -68,7 +79,7 @@ export interface QueueInput {
         name: string;
     };
 }
-interface QueueRow {
+export interface QueueRow {
     id: string;
     conversation_id: string;
     account_id: string;
@@ -83,8 +94,27 @@ interface QueueRow {
     skill: unknown;
     created_at: Date;
 }
+export declare const COLUMNS: readonly ["id", "conversation_id", "account_id", "position", "text", "content", "attachments", "files", "client_message_id", "model", "effort", "skill", "created_at"];
+/**
+ * Queued text as the event log will store it: NUL becomes U+FFFD (PG rejects NUL in text and
+ * jsonb), the mapping `payloadJson` applies to a direct send (final review m1).
+ */
+export declare const noNul: (text: string) => string;
+export declare const itemNotFound: () => ApiError;
+export declare function toItem(r: QueueRow): QueueItem;
+/**
+ * The text rule of `POST …/messages`: text is required unless the message invokes a skill (its
+ * rendered text is `content[0]`) or carries files and no `@` resources (`content[0]` must be the
+ * text when resources follow it).
+ */
+export declare function checkText(text: string, files: number, attachments: number, skill: boolean): void;
+/** The stored form of a rendered invocation and its first content block. */
+export declare function storedSkill(invokedAs: string, invoked: RenderedInvocation): {
+    skill: string;
+    first: LogContentBlock;
+};
 /** The `user_message` a queued item becomes, as `postUserMessage` would have written it. */
-export declare function queuedUserMessage(r: QueueRow): AppendEvent;
+export declare function queuedUserMessage(r: QueueRow, context?: MessageContext): AppendEvent;
 /**
  * Appends a queued item inside `t` (the caller holds the conversation row lock): its pick, re-planned
  * against the selection in effect now, becomes a `model_switched` before the `user_message`, as a
@@ -93,23 +123,36 @@ export declare function queuedUserMessage(r: QueueRow): AppendEvent;
  * (`model_switched { reason: "unavailable" }` before `run_started`) handles it, as it does for a
  * direct switch whose model disappears. Returns the `user_message` and whether it switched.
  */
-export declare function appendQueuedIn(t: KernelTrx, eventLog: Pick<EventLog, "append">, conversationId: string, r: QueueRow): Promise<{
+export declare function appendQueuedIn(t: KernelTrx, eventLog: Pick<EventLog, "appendIn">, conversationId: string, r: QueueRow): Promise<{
     event: ConversationEvent;
     switched: boolean;
+    unarchived: boolean;
 }>;
+/**
+ * Why a queued item's skill can no longer be invoked, or null (also null for a plain message).
+ * Checked at dispatch, inside `t` (phase D Task 9): the rendered text was frozen when queued, but
+ * the skill must still be one of the agent's skills a person can invoke.
+ */
+export declare function queuedSkillBlocked(t: KernelTrx, conversationId: string, r: Pick<QueueRow, "skill">): Promise<import("../skills/invoke.js").NotInvocableReason | null>;
 /** Pauses the queue with `reason` (inside `t`, holding the conversation row lock). */
 export declare function pauseQueueWith(t: KernelTrx, conversationId: string, reason: QueuePauseReason): Promise<void>;
+/** Whether a user_message with this client id is already in the log (inside `t`). */
+export declare function alreadySent(t: KernelTrx, conversationId: string, clientMessageId: string): Promise<boolean>;
+/** Clears the pause once the queue is empty (inside `t`, holding the conversation row lock). */
+export declare function unpauseIfEmpty(t: KernelTrx, conversationId: string): Promise<void>;
+export declare const queueFull: () => ApiError;
 /**
  * Sends the queue's head item as a `user_message` inside `t` (the caller holds the conversation
  * row lock and has checked the conversation is idle and not paused); returns the event, or null
  * when the queue is empty. An item whose message is already in the log (a retried enqueue after it
  * was sent) is dropped and the next one is taken. A head item whose skill can no longer be invoked
  * stays queued and the queue pauses (`skill_not_invocable`): `{ paused }`. The caller notifies
- * after commit.
+ * after commit (and publishes `archived` when the send unarchived the conversation).
  */
-export declare function dispatchQueuedIn(t: KernelTrx, eventLog: Pick<EventLog, "append">, conversationId: string): Promise<{
+export declare function dispatchQueuedIn(t: KernelTrx, eventLog: Pick<EventLog, "appendIn">, conversationId: string): Promise<{
     event: ConversationEvent;
     switched: boolean;
+    unarchived: boolean;
 } | {
     paused: QueuePauseReason;
 } | null>;
@@ -118,52 +161,4 @@ export declare function dispatchQueuedIn(t: KernelTrx, eventLog: Pick<EventLog,
  * (inside the terminal transaction, see `finishRunIn`).
  */
 export declare function pauseQueueIn(t: KernelTrx, conversationId: string): Promise<void>;
-export interface ConversationQueueDeps {
-    db: KernelDb;
-    eventLog: Pick<EventLog, "append" | "notify" | "publishChanged" | "findByIdem">;
-    conversations: Pick<ConversationsService, "get" | "writable" | "resolveExtra" | "bindIn" | "checkFilesSupported" | "checkPick" | "prepareQueuedSkill">;
-    runs?: Pick<RunControl, "ensureRun">;
-}
-/**
- * The queue API (owner only, as the conversation): list, add, edit the text, delete, send now and
- * resume. Every change publishes `changed: queue`.
- */
-export declare class ConversationQueue {
-    private readonly d;
-    constructor(d: ConversationQueueDeps);
-    list(orgId: string, conversationId: string, accountId: string): Promise<{
-        items: QueueItem[];
-        paused: boolean;
-        pauseReason?: QueuePauseReason;
-    }>;
-    /**
-     * Queues a message. `@` resources are read now with the caller's credentials and stored with the
-     * item, and uploaded files are bound to the conversation now, so sending later needs nobody's
-     * credentials. The same `clientMessageId` again returns the queued item (`created: false`), or,
-     * when it was already sent, the sent `user_message` with `item: null`. Then `ensureRun`: on an
-     * idle conversation the item goes out at once.
-     */
-    add(orgId: string, conversationId: string, accountId: string, input: QueueInput): Promise<{
-        item: QueueItem | null;
-        event?: ConversationEvent;
-        created: boolean;
-    }>;
-    /**
-     * Changes a queued item's text (its resources and files stay as queued). A skill invocation's
-     * text is its arguments: the skill is rendered again with them now (phase D Task 9).
-     */
-    edit(orgId: string, conversationId: string, accountId: string, itemId: string, text: string): Promise<QueueItem>;
-    remove(orgId: string, conversationId: string, accountId: string, itemId: string): Promise<void>;
-    /**
-     * Sends a queued item now: it leaves the queue and is posted as a user message in the same
-     * transaction (an interjection when a run is active; the items before it keep their place).
-     * Racing the dispatcher, exactly one of them takes the item; the loser sees it gone (404).
-     */
-    sendNow(orgId: string, conversationId: string, accountId: string, itemId: string): Promise<ConversationEvent>;
-    /** "Continue sending": clears the pause and lets `ensureRun` send the head item. */
-    resume(orgId: string, conversationId: string, accountId: string): Promise<void>;
-    /** A queued item or a sent message for this client id (outside any transaction). */
-    private prior;
-    private lockConversation;
-}
 export {};