@capybara-hq/kernel 0.1.0-rc.15 → 0.1.0-rc.17

package/dist/catalog/marketplaces.service.d.ts

@@ -188,7 +188,7 @@ export declare function headsToResolve(entries: readonly MarketplaceEntry[], imp
 /** The host versions (an entry's `minKernel` is judged against them). */
 export declare const HOST_VERSIONS: {
     readonly kernel: string;
-    readonly sdk: "0.1.0-rc.11";
+    readonly sdk: "0.1.0-rc.13";
 };
 /** Whether this deployment satisfies the entry's `minKernel`. */
 export declare const entryCompatible: (e: Pick<MarketplaceEntry, "minKernel">) => boolean;

package/dist/channels/cards.d.ts

@@ -59,7 +59,11 @@ export declare function approvalCard(d: CardDeps, approvalId: string, base: stri
 /** 答案摘要：每个字段的值（多选用逗号连接），多个字段用分号分隔。 */
 export declare function answerSummary(answer: FormAnswer | null): string | undefined;
 /** 提问卡片。不能在 IM 内作答的表单（`questionRenderableInline` 为 false）由渠道只渲染网页链接。 */
-export declare function questionCard(questionId: string, form: InputForm, state: "pending" | "answered" | "expired" | "cancelled", webUrl: string, answer?: FormAnswer | null): Extract<ChannelCard, {
+export declare function questionCard(questionId: string, form: InputForm, state: Extract<ChannelCard, {
+    kind: "question";
+}>["state"], webUrl: string, answer?: FormAnswer | null, 
+/** A pending card of the delivered conversation's own run: a text reply also works (§10.2). */
+textReply?: "plain" | "mention"): Extract<ChannelCard, {
     kind: "question";
 }>;
 /** 一条只带一张卡片的消息（随附文本为固定话术）。 */

package/dist/channels/cards.js

@@ -210,7 +210,9 @@ export function answerSummary(answer) {
     return parts.length === 0 ? undefined : parts.join("; ");
 }
 /** 提问卡片。不能在 IM 内作答的表单（`questionRenderableInline` 为 false）由渠道只渲染网页链接。 */
-export function questionCard(questionId, form, state, webUrl, answer = null) {
+export function questionCard(questionId, form, state, webUrl, answer = null, 
+/** A pending card of the delivered conversation's own run: a text reply also works (§10.2). */
+textReply) {
     const summary = answerSummary(answer);
     return {
         kind: "question",
@@ -219,6 +221,7 @@ export function questionCard(questionId, form, state, webUrl, answer = null) {
         state,
         ...(summary !== undefined && { answerSummary: summary }),
         webUrl,
+        ...(state === "pending" && textReply !== undefined && { textReply }),
     };
 }
 /** 一条只带一张卡片的消息（随附文本为固定话术）。 */

package/dist/channels/channels.schemas.d.ts

@@ -9,6 +9,10 @@ export declare const ChannelCreateSchema: z.ZodObject<{
         anonymous: "anonymous";
         bind: "bind";
     }>>;
+    inboundMode: z.ZodOptional<z.ZodEnum<{
+        long_connection: "long_connection";
+        webhook: "webhook";
+    }>>;
 }, z.core.$strict>;
 export declare const ChannelPatchSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;

package/dist/channels/channels.schemas.js

@@ -8,6 +8,8 @@ export const ChannelCreateSchema = z
     agentId: z.string().min(1).max(100),
     config: Config,
     unboundPolicy: Policy.optional(),
+    // default long_connection; webhook needs plugin support and channels.webhookBaseUrl (409)
+    inboundMode: z.enum(["long_connection", "webhook"]).optional(),
 })
     .strict();
 export const ChannelPatchSchema = z

package/dist/channels/connections.controller.d.ts

@@ -7,7 +7,7 @@ import { PluginIcons } from "../extensions/plugin-icons.js";
 import { type Principal } from "../identity/principal.js";
 import { type OrgContext } from "../orgs/org.guard.js";
 import { ChannelCreateSchema as CreateBody, ChannelGuideAckSchema as GuideAckBody, ChannelPatchSchema as PatchBody } from "./channels.schemas.js";
-import { ChannelConnections, type ChannelConnectionView } from "./connections.service.js";
+import { ChannelConnections, type ChannelConnectionView, type ChannelInboundInfo } from "./connections.service.js";
 /**
  * A connection as the org's pages show it: its plugin's display name (null when it has none) and
  * the URL of its plugin's icon on the org's catalog route (null without one, or when the org may
@@ -36,13 +36,15 @@ export declare class ChannelConnectionsController {
         channels: ChannelConnectionPage[];
     }>;
     /**
-     * The connection form's JSON Schema, and where the plugin's setup guide is (`guide`, null when
-     * the plugin has none the org may see): 新建渠道 shows it once the plugin is picked.
+     * The connection form's JSON Schema, where the plugin's setup guide is (`guide`, null when the
+     * plugin has none the org may see): 新建渠道 shows it once the plugin is picked; and whether its
+     * connections can use webhook inbound (`inbound`, channel inbound mode fields spec §4).
      */
     schema(org: OrgContext, plugin: string): Promise<{
         plugin: string;
         schema: JsonSchema;
         guide: Omit<SetupGuideRef, "version"> | null;
+        inbound: ChannelInboundInfo;
     }>;
     create(principal: Principal, org: OrgContext, body: z.infer<typeof CreateBody>): Promise<{
         channel: ChannelConnectionPage;

package/dist/channels/connections.controller.js

@@ -16,7 +16,7 @@ import { createZodDto } from "../infra/validation/create-zod-dto.js";
 import { ZBody } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
 import { ChannelCreateSchema as CreateBody, ChannelGuideAckSchema as GuideAckBody, ChannelPatchSchema as PatchBody, } from "./channels.schemas.js";
-import { ChannelConnections } from "./connections.service.js";
+import { ChannelConnections, } from "./connections.service.js";
 class ChannelCreateBody extends createZodDto(CreateBody, "ChannelCreateBody") {
 }
 class ChannelPatchBody extends createZodDto(PatchBody, "ChannelPatchBody") {
@@ -62,13 +62,15 @@ let ChannelConnectionsController = class ChannelConnectionsController {
         return { channels: await this.withPlugins(org, await this.channels.list(org.orgId)) };
     }
     /**
-     * The connection form's JSON Schema, and where the plugin's setup guide is (`guide`, null when
-     * the plugin has none the org may see): 新建渠道 shows it once the plugin is picked.
+     * The connection form's JSON Schema, where the plugin's setup guide is (`guide`, null when the
+     * plugin has none the org may see): 新建渠道 shows it once the plugin is picked; and whether its
+     * connections can use webhook inbound (`inbound`, channel inbound mode fields spec §4).
      */
     async schema(org, plugin) {
         const schema = this.channels.jsonSchema(plugin);
+        const inbound = this.channels.inboundInfo(plugin);
         const g = (await this.guides.channelGuides([plugin], org)).get(plugin);
-        return { plugin, schema, guide: g ? { itemId: g.itemId, guideId: g.guideId } : null };
+        return { plugin, schema, guide: g ? { itemId: g.itemId, guideId: g.guideId } : null, inbound };
     }
     async create(principal, org, body) {
         const p = requireUser(principal);

package/dist/channels/connections.service.d.ts

@@ -15,6 +15,11 @@ import { OrgLock } from "../orgs/org-lock.js";
 import type { OrgRole } from "../orgs/roles.js";
 import { ChannelJobs } from "./jobs.js";
 import type { ChannelLocale } from "./phrases.js";
+/**
+ * A public https address: https, and the host is not loopback, a private / link-local / reserved
+ * IP, `localhost`, `*.localhost`, `*.local`, `*.internal` or a single label (no DNS lookup).
+ */
+export declare function isPublicHttpsUrl(url: string): boolean;
 /** 连接配置里全部密钥字段存成一行：`{ 点路径: 值 }` 的 JSON。 */
 export declare const connectionSecretKey: (connectionId: string) => string;
 /**
@@ -82,6 +87,18 @@ export interface CreateChannelInput {
     agentId: string;
     config: Record<string, unknown>;
     unboundPolicy?: UnboundPolicy | undefined;
+    /** Default `long_connection`; `webhook` needs plugin support and `channels.webhookBaseUrl`. */
+    inboundMode?: InboundMode | undefined;
+}
+/**
+ * Whether a channel plugin's connections can use webhook inbound (channel inbound mode fields spec
+ * §4): the plugin implements `Channel.webhook`; the kernel accepts webhook mode (a usable
+ * `channels.webhookBaseUrl`); and that base URL is a public https address.
+ */
+export interface ChannelInboundInfo {
+    webhookSupported: boolean;
+    webhookAvailable: boolean;
+    webhookPublic: boolean;
 }
 /** `config` 里的密钥字段：缺省 = 保留原值、`null` = 清除、其他值 = 新值（同组织插件配置）。 */
 export interface UpdateChannelInput {
@@ -163,6 +180,15 @@ export declare class ChannelConnections implements OnApplicationShutdown {
      * `channels.webhookBaseUrl` (otherwise there is no URL to give the platform): 409 otherwise.
      */
     private assertWebhookAvailable;
+    /**
+     * The fields the inbound mode requires (`x-ui.inboundModes`, channel inbound mode fields spec
+     * §3) must have a value in `full` (the parsed config, stored secrets included): 400
+     * `extension.config_invalid` with one issue per missing field otherwise. A plugin without the
+     * hint passes.
+     */
+    private assertModeFields;
+    /** Whether the plugin's connections can use webhook inbound (spec §4); `extension.not_found`. */
+    inboundInfo(plugin: string): ChannelInboundInfo;
     private viewOf;
     private live;
     list(orgId: string): Promise<ChannelConnectionView[]>;

package/dist/channels/connections.service.js

@@ -8,7 +8,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { randomUUID } from "node:crypto";
-import { CHANNEL_EXTENSION_POINT, } from "@capybara-hq/plugin-sdk";
+import { isIP } from "node:net";
+import { CHANNEL_EXTENSION_POINT, missingInboundModeFields, } from "@capybara-hq/plugin-sdk";
 import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
 import { configFields, getPath, secretScalars, secretValues } from "../config/fields.js";
@@ -28,11 +29,35 @@ import { Transactional } from "../infra/database/transactional.decorator.js";
 import { KernelEvents } from "../infra/events/kernel-events.js";
 import { KERNEL_BUS, KERNEL_LOGGER, KEYRING, REDIS } from "../infra/tokens.js";
 import { createRedactor } from "../log.js";
+import { isForbiddenAddress, isLoopbackHost, normalizeHost } from "../net/public-address.js";
 import { OrgLock } from "../orgs/org-lock.js";
 import { readOrgSettings } from "../orgs/settings.service.js";
 import { adaptToFeatures } from "./features.js";
 import { ChannelJobs } from "./jobs.js";
 import { webhookBase, webhookUrlOf } from "./webhook-url.js";
+/**
+ * A public https address: https, and the host is not loopback, a private / link-local / reserved
+ * IP, `localhost`, `*.localhost`, `*.local`, `*.internal` or a single label (no DNS lookup).
+ */
+export function isPublicHttpsUrl(url) {
+    let u;
+    try {
+        u = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    if (u.protocol !== "https:")
+        return false;
+    const host = normalizeHost(u.hostname);
+    if (isLoopbackHost(host))
+        return false;
+    if (isIP(host) !== 0)
+        return !isForbiddenAddress(host);
+    if (!host.includes("."))
+        return false;
+    return ![".localhost", ".local", ".internal"].some((s) => host.endsWith(s));
+}
 /** 内核 secrets 命名空间（插件名不能取 `kernel`）。 */
 const SECRETS_NAMESPACE = "kernel";
 /** 连接配置里全部密钥字段存成一行：`{ 点路径: 值 }` 的 JSON。 */
@@ -305,6 +330,38 @@ let ChannelConnections = class ChannelConnections {
             throw new ApiError("channel.webhook_unavailable", "Webhook inbound needs channels.webhookBaseUrl to be configured");
         }
     }
+    /**
+     * The fields the inbound mode requires (`x-ui.inboundModes`, channel inbound mode fields spec
+     * §3) must have a value in `full` (the parsed config, stored secrets included): 400
+     * `extension.config_invalid` with one issue per missing field otherwise. A plugin without the
+     * hint passes.
+     */
+    assertModeFields(plugin, schema, mode, full) {
+        const js = this.formSchema(plugin, this.versionOf(plugin), schema)?.schema;
+        if (js === undefined)
+            return;
+        const missing = missingInboundModeFields(js, mode, (field) => {
+            const v = getPath(full, field);
+            return v !== undefined && v !== null && v !== "";
+        });
+        if (missing.length === 0)
+            return;
+        throw new ApiError("extension.config_invalid", `Invalid channel connection config for extension ${plugin}`, missing.map((field) => ({
+            path: field,
+            segments: [field],
+            message: `required in ${mode} mode`,
+        })));
+    }
+    /** Whether the plugin's connections can use webhook inbound (spec §4); `extension.not_found`. */
+    inboundInfo(plugin) {
+        const webhookSupported = this.channel(plugin).webhook !== undefined;
+        const base = this.webhookBase();
+        return {
+            webhookSupported,
+            webhookAvailable: webhookSupported && base !== undefined,
+            webhookPublic: webhookSupported && base !== undefined && isPublicHttpsUrl(base),
+        };
+    }
     async viewOf(row) {
         return this.view(row, new Set(Object.keys(await this.readSecrets(row.org_id, row.id))));
     }
@@ -331,14 +388,16 @@ let ChannelConnections = class ChannelConnections {
         await this.assertEnabled(orgId, input.plugin);
         const schema = channel.connectionSchema;
         const full = this.parse(input.plugin, schema, input.config);
+        const mode = input.inboundMode ?? "long_connection";
+        if (mode === "webhook")
+            this.assertWebhookAvailable(input.plugin);
+        this.assertModeFields(input.plugin, schema, mode, full);
         await this.assertAgent(orgId, input.agentId);
         const verified = await this.verify(channel, full);
         const id = randomUUID();
         const { plain, secrets } = split(schema, full);
-        // the guide the 新建渠道 page showed: the plugin's current one, for the default mode
-        const guideAck = await this.guides.currentAck(input.plugin, "channel-connection", {
-            mode: "long_connection",
-        });
+        // the guide the 新建渠道 page showed: the plugin's current one, for the mode picked there
+        const guideAck = await this.guides.currentAck(input.plugin, "channel-connection", { mode });
         const row = await this.insertIn({
             orgId,
             id,
@@ -372,6 +431,7 @@ let ChannelConnections = class ChannelConnections {
             agent_id: input.agentId,
             config: JSON.stringify(a.plain),
             unbound_policy: input.unboundPolicy ?? "bind",
+            inbound_mode: input.inboundMode ?? "long_connection",
             bot_user_id: a.verified.botUserId,
             tenant_id: a.verified.tenantId,
             guide_ack: a.guideAck === null ? null : JSON.stringify(a.guideAck),
@@ -385,7 +445,11 @@ let ChannelConnections = class ChannelConnections {
             orgId,
             action: "channel.created",
             target: id,
-            detail: { plugin: input.plugin, agentId: input.agentId },
+            detail: {
+                plugin: input.plugin,
+                agentId: input.agentId,
+                inboundMode: input.inboundMode ?? "long_connection",
+            },
         });
         return inserted;
     }
@@ -437,6 +501,15 @@ let ChannelConnections = class ChannelConnections {
         const modeChanged = patch.inboundMode !== undefined && patch.inboundMode !== current.inbound_mode;
         if (modeChanged && patch.inboundMode === "webhook")
             this.assertWebhookAvailable(current.plugin);
+        if (rotated || modeChanged) {
+            // the fields the effective mode requires (spec §3): the new config, else the stored one
+            const schema = this.channel(current.plugin).connectionSchema;
+            const full = rotated?.full ?? {
+                ...(current.config ?? {}),
+                ...(await this.readSecrets(orgId, id)),
+            };
+            this.assertModeFields(current.plugin, schema, patch.inboundMode ?? current.inbound_mode, full);
+        }
         if (patch.agentId !== undefined)
             await this.assertAgent(orgId, patch.agentId);
         // A mode switch sets the platform app up for the new mode: the guide of that mode is the one

package/dist/channels/outbound.js

@@ -894,7 +894,10 @@ class Delivery {
             await this.send({ text: phrase("handleOnWeb", this.locale) }, this.key(seq));
             return this.advance(seq);
         }
-        const card = questionCard(questionId, form, "pending", this.questionUrl(this.base, child));
+        // the person can skip the conversation's own question by replying; a sub-agent's question
+        // stays answerable on its card only (reply-while-question spec §4.3)
+        const textReply = child === undefined ? (this.target.chatType === "dm" ? "plain" : "mention") : undefined;
+        const card = questionCard(questionId, form, "pending", this.questionUrl(this.base, child), null, textReply);
         await this.recordCard("question", card.id);
         const { messageId } = await this.send(cardMessage(phrase("questionTitle", this.locale), card), this.key(seq));
         return this.advance(seq, { card: { kind: "question", id: card.id, messageId } });

package/dist/conversations/conversations.service.d.ts

@@ -6,10 +6,12 @@ import type { TitleSource } from "../db/kernel-schema.js";
 import { ConversationDevices, type NewConversationDevice } from "../devices/conversation-devices.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
+import { KernelEvents } from "../infra/events/kernel-events.js";
 import type { KernelLogger } from "../log.js";
 import { ProviderRegistry } from "../runtime/providers.js";
 import { type RenderedInvocation, SkillInvoker } from "../skills/invoke.js";
 import { ConnectorContent } from "../tools/connector-content.js";
+import { type QuestionRecord, QuestionsService } from "../tools/questions.service.js";
 import { ConversationAccess } from "./access.js";
 import { type AgentTreeNode } from "./agent-tree.js";
 import { AttachmentsService } from "./attachments.service.js";
@@ -207,6 +209,9 @@ export declare class ConversationsService {
     private readonly background;
     /** The device a new conversation is bound to (environments spec §4.1 item 1). */
     private readonly devices;
+    /** A starter's message skips the run's pending questions (reply-while-question spec §8.1). */
+    private readonly questions;
+    private readonly events;
     readonly txHost: TransactionHost;
     constructor(db: KernelDb, eventLog: EventLog, agents: Pick<AgentLookup, "get">, access: Pick<ConversationAccess, "isAccessible">, 
     /** Starts and stops the conversation's runs. */
@@ -222,7 +227,9 @@ export declare class ConversationsService {
     /** Stops a deleted conversation's background tasks. */
     background: Pick<BackgroundTaskStopper, "stopForDeletedConversation">, 
     /** The device a new conversation is bound to (environments spec §4.1 item 1). */
-    devices: Pick<ConversationDevices, "forNew">, txHost: TransactionHost);
+    devices: Pick<ConversationDevices, "forNew">, 
+    /** A starter's message skips the run's pending questions (reply-while-question spec §8.1). */
+    questions: Pick<QuestionsService, "skipPendingIn">, events: Pick<KernelEvents, "emit">, txHost: TransactionHost);
     /**
      * 不阻塞地调用一次 `ensureRun`（打开 SSE、读事件时）：它幂等，并顺带清理孤儿运行，
      * 会话不会因为某次运行结束后的投递失败而永远停在「运行中」。失败只记日志。
@@ -408,10 +415,27 @@ export declare class ConversationsService {
      * queue re-plans it against the selection in effect at dispatch.
      */
     checkPick(orgId: string, conv: ConversationView, accountId: string, pick: Pick<UserMessageInput, "model" | "effort">): Promise<void>;
+    /**
+     * Skips, in the caller's transaction (it wrote `accountId`'s message at `messageSeq` and holds the
+     * conversation row lock), the pending questions that message closes (reply-while-question spec
+     * §8.1). The queue's "send now" uses it as the direct send does; announce after the commit with
+     * {@link announceSkipped}.
+     */
+    skipQuestionsIn(conversationId: string, accountId: string, messageSeq: number): Promise<{
+        records: QuestionRecord[];
+        toSeq: number | null;
+    }>;
+    /**
+     * After the commit: announces each skipped question (`question.answered`, outcome `skipped`), so
+     * its run resumes (waits) and its IM card updates (channel jobs).
+     */
+    announceSkipped(records: readonly QuestionRecord[]): Promise<void>;
     /**
      * Writes the message (preceded by its `model_switched` when it switches) inside `t` and updates
      * `conversations.selection`; returns the events written, in seq order (the `user_message`
-     * last). The caller notifies after commit.
+     * last). A message this call newly wrote (not a retry's deduped one) then skips the pending
+     * questions its author may answer (reply-while-question spec §8.1): `skipped` and the highest
+     * seq their events took. The caller notifies and emits `question.answered` after commit.
      */
     private writeMessage;
     /**

package/dist/conversations/conversations.service.js

@@ -18,12 +18,14 @@ import { ApiError } from "../errors.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import { Transactional } from "../infra/database/transactional.decorator.js";
+import { KernelEvents } from "../infra/events/kernel-events.js";
 import { KERNEL_LOGGER } from "../infra/tokens.js";
 import { ProviderRegistry } from "../runtime/providers.js";
 import { RunControl as RunControlService } from "../runtime/run-control.js";
 import { rootConversationOf } from "../runtime/subagents/child.js";
 import { SkillInvoker } from "../skills/invoke.js";
 import { ConnectorContent } from "../tools/connector-content.js";
+import { QuestionsService } from "../tools/questions.service.js";
 import { ConversationAccess, parentReachable } from "./access.js";
 import { readAgentTree } from "./agent-tree.js";
 import { AttachmentsService } from "./attachments.service.js";
@@ -130,6 +132,8 @@ let ConversationsService = class ConversationsService {
     invoker;
     background;
     devices;
+    questions;
+    events;
     txHost;
     constructor(db, eventLog, agents, access, 
     /** Starts and stops the conversation's runs. */
@@ -145,7 +149,9 @@ let ConversationsService = class ConversationsService {
     /** Stops a deleted conversation's background tasks. */
     background, 
     /** The device a new conversation is bound to (environments spec §4.1 item 1). */
-    devices, txHost) {
+    devices, 
+    /** A starter's message skips the run's pending questions (reply-while-question spec §8.1). */
+    questions, events, txHost) {
         this.db = db;
         this.eventLog = eventLog;
         this.agents = agents;
@@ -158,6 +164,8 @@ let ConversationsService = class ConversationsService {
         this.invoker = invoker;
         this.background = background;
         this.devices = devices;
+        this.questions = questions;
+        this.events = events;
         this.txHost = txHost;
     }
     /**
@@ -246,7 +254,9 @@ let ConversationsService = class ConversationsService {
         if (!row)
             return undefined;
         const blocks = await this.bindIn(orgId, id, accountId, input.files ?? []);
-        return this.writeMessage(orgId, id, accountId, input, next, extra, blocks, invoked);
+        // a new conversation has no run yet, so nothing to skip
+        return (await this.writeMessage(orgId, id, accountId, input, next, extra, blocks, invoked))
+            .events;
     }
     /**
      * The conversation (and its first event) an earlier first send with this id created. The id used
@@ -716,8 +726,9 @@ let ConversationsService = class ConversationsService {
             : await this.prepareSkill(orgId, conv.agentId, conversationId, agent, input);
         // one transaction: the sender, time zone and language are read with the message's write
         // (run context spec §3.2)
-        const event = await this.postIn(orgId, conversationId, accountId, input, next, extra, invoked);
-        await this.eventLog.notify(conversationId, event.seq);
+        const { event, skipped, toSeq } = await this.postIn(orgId, conversationId, accountId, input, next, extra, invoked);
+        await this.eventLog.notify(conversationId, toSeq);
+        await this.announceSkipped(skipped);
         if (next !== null)
             await this.eventLog.publishChanged(conversationId, "selection");
         // The message is written: it brings an archived conversation back into the default lists
@@ -740,7 +751,12 @@ let ConversationsService = class ConversationsService {
     async postIn(orgId, conversationId, accountId, input, next, extra, invoked) {
         const blocks = await this.bindIn(orgId, conversationId, accountId, input.files ?? []);
         const written = await this.writeMessage(orgId, conversationId, accountId, input, next, extra, blocks, invoked);
-        return written.at(-1);
+        const event = written.events.at(-1);
+        return {
+            event,
+            skipped: written.skipped,
+            toSeq: Math.max(event.seq, written.skippedToSeq ?? 0),
+        };
     }
     /**
      * The selection a message switches to, or null when it changes nothing. A model equal to the
@@ -779,10 +795,36 @@ let ConversationsService = class ConversationsService {
         const agent = await this.agents.get(orgId, conv.agentId, accountId);
         await this.planSwitch(orgId, agent.definition, conv.selection, pick);
     }
+    /**
+     * Skips, in the caller's transaction (it wrote `accountId`'s message at `messageSeq` and holds the
+     * conversation row lock), the pending questions that message closes (reply-while-question spec
+     * §8.1). The queue's "send now" uses it as the direct send does; announce after the commit with
+     * {@link announceSkipped}.
+     */
+    async skipQuestionsIn(conversationId, accountId, messageSeq) {
+        return this.questions.skipPendingIn(conversationId, accountId, messageSeq);
+    }
+    /**
+     * After the commit: announces each skipped question (`question.answered`, outcome `skipped`), so
+     * its run resumes (waits) and its IM card updates (channel jobs).
+     */
+    async announceSkipped(records) {
+        for (const q of records) {
+            await this.events.emit("question.answered", {
+                id: q.id,
+                orgId: q.orgId,
+                conversationId: q.conversationId,
+                runId: q.runId,
+                outcome: "skipped",
+            });
+        }
+    }
     /**
      * Writes the message (preceded by its `model_switched` when it switches) inside `t` and updates
      * `conversations.selection`; returns the events written, in seq order (the `user_message`
-     * last). The caller notifies after commit.
+     * last). A message this call newly wrote (not a retry's deduped one) then skips the pending
+     * questions its author may answer (reply-while-question spec §8.1): `skipped` and the highest
+     * seq their events took. The caller notifies and emits `question.answered` after commit.
      */
     async writeMessage(orgId, conversationId, accountId, input, next, extra, blocks, invoked) {
         const events = [];
@@ -803,7 +845,11 @@ let ConversationsService = class ConversationsService {
             im: input.im,
         });
         events.push(this.userMessage(accountId, input, extra, blocks, invoked, context));
-        const written = await this.eventLog.appendIn(conversationId, events);
+        const { events: written, fresh } = await this.eventLog.appendInReport(conversationId, events);
+        const message = written.at(-1);
+        const skips = fresh.at(-1) === true
+            ? await this.skipQuestionsIn(conversationId, accountId, message.seq)
+            : { records: [], toSeq: null };
         if (next !== null) {
             const t = this.db.db;
             // the cache follows the log (a retried message's switch may be an old, deduped event that a
@@ -814,7 +860,7 @@ let ConversationsService = class ConversationsService {
                 .where("id", "=", conversationId)
                 .execute();
         }
-        return written;
+        return { events: written, skipped: skips.records, skippedToSeq: skips.toSeq };
     }
     /**
      * Renders the message's skill invocation (phase D), or undefined when it has none. Resolved
@@ -940,6 +986,9 @@ __decorate([
 __decorate([
     Transactional({ propagation: "requires_new" })
 ], ConversationsService.prototype, "postIn", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], ConversationsService.prototype, "skipQuestionsIn", null);
 __decorate([
     Transactional({ propagation: "mandatory" })
 ], ConversationsService.prototype, "writeMessage", null);
@@ -960,6 +1009,8 @@ ConversationsService = __decorate([
     __param(9, Inject(SkillInvoker)),
     __param(10, Inject(BackgroundTaskStopper)),
     __param(11, Inject(ConversationDevices)),
-    __param(12, Inject(TransactionHost))
+    __param(12, Inject(QuestionsService)),
+    __param(13, Inject(KernelEvents)),
+    __param(14, Inject(TransactionHost))
 ], ConversationsService);
 export { ConversationsService };

package/dist/conversations/event-log.d.ts

@@ -97,6 +97,15 @@ export declare class EventLog {
      * commit with the highest seq it wrote.
      */
     appendIn(conversationId: string, events: AppendEvent[]): Promise<ConversationEvent[]>;
+    /**
+     * {@link appendIn} that also says, per input, whether this call wrote the event (`fresh[i]`) or
+     * returned an earlier one by its idempotency key (a retried message, reply-while-question spec
+     * §8.1). Same transaction contract: the caller's, `mandatory`.
+     */
+    appendInReport(conversationId: string, events: AppendEvent[]): Promise<{
+        events: ConversationEvent[];
+        fresh: boolean[];
+    }>;
     private appendOwn;
     /**
      * 发布「日志已推进到 toSeq」；发布失败只记日志（事件已提交，订阅方可按 seq 补读）。Then announces

package/dist/conversations/event-log.js

@@ -110,11 +110,21 @@ let EventLog = class EventLog {
      * commit with the highest seq it wrote.
      */
     async appendIn(conversationId, events) {
+        return (await this.appendInReport(conversationId, events)).events;
+    }
+    /**
+     * {@link appendIn} that also says, per input, whether this call wrote the event (`fresh[i]`) or
+     * returned an earlier one by its idempotency key (a retried message, reply-while-question spec
+     * §8.1). Same transaction contract: the caller's, `mandatory`.
+     */
+    async appendInReport(conversationId, events) {
         const bodies = events.map((e) => this.validate(e));
-        return (await this.write(conversationId, events, bodies)).events;
+        const { events: out, fresh } = await this.write(conversationId, events, bodies);
+        return { events: out, fresh };
     }
     async appendOwn(conversationId, events, bodies) {
-        return this.write(conversationId, events, bodies);
+        const { events: out, toSeq } = await this.write(conversationId, events, bodies);
+        return { events: out, toSeq };
     }
     /**
      * 发布「日志已推进到 toSeq」；发布失败只记日志（事件已提交，订阅方可按 seq 补读）。Then announces
@@ -333,10 +343,14 @@ let EventLog = class EventLog {
                 fresh.push(i);
             }
         });
+        // written by this call: the first input of each new event (a repeat in the batch points to it)
+        const freshSet = new Set(fresh);
+        const isFresh = events.map((_, i) => freshSet.has(i));
         if (fresh.length === 0) {
             return {
                 events: plan.map((p) => p.event),
                 toSeq: null,
+                fresh: isFresh,
             };
         }
         const n = fresh.length;
@@ -368,12 +382,16 @@ let EventLog = class EventLog {
         return {
             events: plan.map((p) => p.kind === "old" ? p.event : bySeq.get(base + p.index + 1)),
             toSeq,
+            fresh: isFresh,
         };
     }
 };
 __decorate([
     Transactional({ propagation: "mandatory" })
 ], EventLog.prototype, "appendIn", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], EventLog.prototype, "appendInReport", null);
 __decorate([
     Transactional({ propagation: "requires_new" })
 ], EventLog.prototype, "appendOwn", null);

package/dist/conversations/events.d.ts

@@ -687,7 +687,9 @@ export declare const ConversationEventSchema: z.ZodDiscriminatedUnion<[z.ZodObje
             answered: "answered";
             cancelled: "cancelled";
             expired: "expired";
+            skipped: "skipped";
         }>;
+        skippedBySeq: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"media_excluded">;

package/dist/conversations/events.js

@@ -539,13 +539,18 @@ export const ConversationEventSchema = z.discriminatedUnion("type", [
         form: InputFormSchema,
         expiresAt: z.string(),
     })),
-    /** 输入请求已结束：回答 / 超时 / 取消（后两者 `answer` 与 `byAccountId` 为 null）。 */
+    /**
+     * An input request ended: answered, skipped (the run's starter sent a message instead; `answer`
+     * null, `byAccountId` the message's author, `skippedBySeq` that `user_message`'s seq, written in
+     * the same transaction), expired or cancelled (`answer` and `byAccountId` null). Not model-visible.
+     */
     ev("question_answered", z.object({
         questionId: z.string(),
         callId: z.string(),
         answer: FormAnswerSchema.nullable(),
         byAccountId: z.string().nullable(),
-        outcome: z.enum(["answered", "expired", "cancelled"]),
+        outcome: z.enum(["answered", "skipped", "expired", "cancelled"]),
+        skippedBySeq: seqNo.optional(),
     })),
     /**
      * 带媒体的模型请求被供应商以不可重试的 `invalid_request` / `context_overflow` 拒绝（Ruling M8）：这些附件

package/dist/conversations/queue.service.d.ts

@@ -15,7 +15,7 @@ export declare class ConversationQueue {
     /** Starts the conversation's next run (`ensureRun`). */
     private readonly runs;
     readonly txHost: TransactionHost;
-    constructor(db: KernelDb, eventLog: Pick<EventLog, "appendIn" | "notify" | "publishChanged" | "findByIdem">, conversations: Pick<ConversationsService, "get" | "writable" | "resolveExtra" | "bindIn" | "checkPick" | "prepareQueuedSkill">, 
+    constructor(db: KernelDb, eventLog: Pick<EventLog, "appendIn" | "notify" | "publishChanged" | "findByIdem">, conversations: Pick<ConversationsService, "get" | "writable" | "resolveExtra" | "bindIn" | "checkPick" | "prepareQueuedSkill" | "skipQuestionsIn" | "announceSkipped">, 
     /** Starts the conversation's next run (`ensureRun`). */
     runs: Pick<RunControl, "ensureRun" | "wakeHeldTree">, txHost: TransactionHost);
     list(orgId: string, conversationId: string, accountId: string): Promise<{

package/dist/conversations/queue.service.js

@@ -242,9 +242,10 @@ let ConversationQueue = class ConversationQueue {
      */
     async sendNow(orgId, conversationId, accountId, itemId) {
         await this.conversations.writable(orgId, conversationId, accountId);
-        const { event, fresh, switched, unarchived } = await this.sendNowIn(conversationId, itemId);
+        const { event, fresh, switched, unarchived, skipped, toSeq } = await this.sendNowIn(conversationId, itemId);
         if (fresh)
-            await this.eventLog.notify(conversationId, event.seq);
+            await this.eventLog.notify(conversationId, toSeq);
+        await this.conversations.announceSkipped(skipped);
         if (switched)
             await this.eventLog.publishChanged(conversationId, "selection");
         if (unarchived)
@@ -284,7 +285,17 @@ let ConversationQueue = class ConversationQueue {
         const sent = await alreadySent(t, conversationId, row.client_message_id);
         const out = await appendQueuedIn(t, this.eventLog, conversationId, row);
         await unpauseIfEmpty(t, conversationId);
-        return { ...out, fresh: !sent };
+        // sent during the run, the item is the author's message like a direct send: it skips the
+        // pending questions they may answer (reply-while-question spec §4.2)
+        const skips = sent
+            ? { records: [], toSeq: null }
+            : await this.conversations.skipQuestionsIn(conversationId, row.account_id, out.event.seq);
+        return {
+            ...out,
+            fresh: !sent,
+            skipped: skips.records,
+            toSeq: Math.max(out.event.seq, skips.toSeq ?? 0),
+        };
     }
     /** "Continue sending": clears the pause and lets `ensureRun` send the head item. */
     async resume(orgId, conversationId, accountId) {

package/dist/db/kernel-schema.d.ts

@@ -518,7 +518,7 @@ export interface QuestionsTable {
     run_id: string;
     call_id: string;
     spec: Json<unknown>;
-    status: Generated<"pending" | "answered" | "expired" | "cancelled">;
+    status: Generated<"pending" | "answered" | "skipped" | "expired" | "cancelled">;
     answer: ColumnType<unknown, string | null | undefined, string | null>;
     answered_by: string | null;
     answered_at: TsNullable;

package/dist/evals/trajectory.d.ts

@@ -58,8 +58,10 @@ export interface TrajectoryToolCall {
     question: {
         questionId: string;
         askedAt: string;
-        outcome: "answered" | "expired" | "cancelled" | null;
+        outcome: "answered" | "skipped" | "expired" | "cancelled" | null;
         byAccountId: string | null;
+        /** A skipped question: the seq of the user message that skipped it. */
+        skippedBySeq?: number;
     } | null;
     /** A `tool.preExecute` policy hook denied the call (it never started). */
     hookDenied?: TrajectoryHookDenial;

package/dist/evals/trajectory.js

@@ -281,6 +281,9 @@ function buildRun({ started, events }, prices, forks) {
                         askedAt: iso(q.createdAt),
                         outcome: ans?.payload.outcome ?? null,
                         byAccountId: ans?.payload.byAccountId ?? null,
+                        ...(ans?.payload.skippedBySeq !== undefined && {
+                            skippedBySeq: ans.payload.skippedBySeq,
+                        }),
                     },
             };
         });

package/dist/extensions/guide-places.d.ts

@@ -4,8 +4,10 @@ import type { KernelDb } from "../infra/database/kernel-db.js";
 import type { OrgAction } from "../orgs/roles.js";
 /** Why a known variable has no value: what the web and the `Platform` tool tell the reader. */
 export type UnresolvedReason = 
-/** The target is not saved yet (the webhook URL, a connection name nobody typed). */
+/** The target is not saved yet (the webhook URL). */
 "not_saved"
+/** No name typed yet on the new target's form (a connection name on 新建渠道). */
+ | "no_name"
 /** `http.publicUrl` is not set (the URLs built from it). */
  | "public_url"
 /** `channels.webhookBaseUrl` is not set or unusable. */

package/dist/extensions/guide-places.js

@@ -58,7 +58,7 @@ export async function resolvePlace(ctx) {
         const typed = ctx.query.name?.trim();
         values.connectionName =
             connection?.name ?? (typed === undefined || typed === "" ? null : typed);
-        reasons.connectionName = "not_saved";
+        reasons.connectionName = "no_name";
         if (connection !== undefined) {
             target = { kind: "channel-connection", id: connection.id };
             storedMode = connection.inbound_mode;

package/dist/extensions/permission-view.d.ts

@@ -12,11 +12,11 @@ import type { ExtensionSource } from "./sources.js";
 export declare function reviewHash(set: PermissionSet, warnings?: readonly PackageWarning[]): string;
 /** 权限清单展示用的一组：按类别分组，`sensitive` 标出需要管理员特别留意的类别。 */
 export interface PermissionGroup {
-    category: "provides" | "requires" | "optional" | "config" | "tables" | "secrets" | "storage" | "http" | "publicRoutes" | "tools" | "hooks" | "models" | "network" | "ui" | "client";
+    category: "provides" | "requires" | "optional" | "config" | "tables" | "secrets" | "storage" | "http" | "publicRoutes" | "tools" | "hooks" | "models" | "network" | "ui" | "components" | "client";
     /**
-     * Sensitive category: secrets, public routes, tools, hooks, client code; also the "provides" group
-     * when it holds one of {@link SENSITIVE_EXTENSION_POINTS}, and the "UI" group when it holds an
-     * embedded app (embed: the extension's own page in an iframe) or a client component.
+     * Sensitive category: secrets, public routes, tools, hooks, client components, client code; also
+     * the "provides" group when it holds one of {@link SENSITIVE_EXTENSION_POINTS}, and the "UI" group
+     * (views and embeds) when it holds an embedded app (embed: the extension's own page in an iframe).
      */
     sensitive: boolean;
     items: string[];

package/dist/extensions/permission-view.js

@@ -38,6 +38,7 @@ const ALWAYS_SENSITIVE = new Set([
     "publicRoutes",
     "tools",
     "hooks",
+    "components",
     "client",
 ]);
 const CATEGORY_REASON = {
@@ -45,13 +46,14 @@ const CATEGORY_REASON = {
     publicRoutes: "public_routes",
     tools: "tools",
     hooks: "hooks",
+    components: "ui_component",
     client: "client_code",
 };
 /**
  * Why an item in a category is sensitive (undefined when it is not; shared by the grouped list, the
  * per-item `added` and the CLI markers): secrets, public routes, tools, hooks and client code are
- * always sensitive; {@link SENSITIVE_EXTENSION_POINTS} in "provides"; embedded apps (`embed:<id>`)
- * and client components (`component:<id>`) in "UI".
+ * always sensitive, and so are client components (their own group, items are the component ids);
+ * {@link SENSITIVE_EXTENSION_POINTS} in "provides"; embedded apps (`embed:<id>`) in "UI".
  */
 function itemReason(category, item) {
     // storage 不算敏感：ctx.storage 的键由内核加前缀 `plugins/<插件>/<orgId>/`，插件只能读写自己的前缀
@@ -63,8 +65,6 @@ function itemReason(category, item) {
     if (category === "ui") {
         if (item.startsWith("embed:"))
             return "ui_embed";
-        if (item.startsWith("component:"))
-            return "ui_component";
         return undefined;
     }
     return ALWAYS_SENSITIVE.has(category) ? CATEGORY_REASON[category] : undefined;
@@ -89,7 +89,7 @@ function keyItem(key) {
         ["permissions.hooks:", "hooks", ""],
         ["permissions.hooks.policy:", "hooks", "policy:"],
         ["ui.embed:", "ui", "embed:"],
-        [UI_COMPONENT_KEY_PREFIX, "ui", "component:"],
+        [UI_COMPONENT_KEY_PREFIX, "components", ""],
         ["ui.view:", "ui", "view:"],
     ];
     for (const [prefix, category, itemPrefix] of table) {
@@ -162,12 +162,9 @@ export function permissionGroups(set) {
         { category: "network", items: p.network },
         {
             category: "ui",
-            items: [
-                ...ui.views.map((v) => `view:${v}`),
-                ...ui.embeds.map((e) => `embed:${e}`),
-                ...components.map((c) => `component:${c}`),
-            ],
+            items: [...ui.views.map((v) => `view:${v}`), ...ui.embeds.map((e) => `embed:${e}`)],
         },
+        { category: "components", items: components },
         { category: "client", items: p.client === true ? [CLIENT_ITEM] : [] },
     ];
     return groups

package/dist/infra/events/kernel-events.d.ts

@@ -34,7 +34,8 @@ export interface KernelEventMap {
         status: "approved" | "denied";
     };
     /**
-     * A person answered a tool call's input request (after the commit, exactly once). Same
+     * A person answered a tool call's input request, or skipped it with a message (after the commit,
+     * exactly once). Same
      * consumers and the same re-derivation as `approval.decided`.
      */
     "question.answered": {
@@ -42,6 +43,8 @@ export interface KernelEventMap {
         orgId: string;
         conversationId: string;
         runId: string;
+        /** `skipped`: the run's starter sent a message instead (reply-while-question spec §6.3). */
+        outcome: "answered" | "skipped";
     };
     /**
      * EventAppended: a conversation's event log advanced to `toSeq` (after the commit, from

package/dist/tools/builtins/ask-user.js

@@ -5,8 +5,9 @@ const SPEC = {
         "need the user's preference or decision to continue, or when a request is ambiguous; do not use " +
         "it for questions you can answer yourself. Each question has a short header, 2-4 options with a " +
         "label and a description, and can allow selecting several options (multiSelect). The user can " +
-        "always choose Other and type their own answer instead. The run pauses until the user answers; " +
-        "if they do not answer in time, the result says so.",
+        "always choose Other and type their own answer instead. The run pauses until the user answers. " +
+        "The user may instead reply with a message; then the result says so and their message follows. " +
+        "If they do not answer in time, the result says so.",
     inputSchema: {
         type: "object",
         properties: {

package/dist/tools/pipeline.d.ts

@@ -35,6 +35,13 @@ export declare const approvalExpiredText: (hours: number) => string;
 export declare const APPROVAL_CANCELLED_TEXT = "The run was stopped while waiting for approval.";
 /** 等待用户输入期间 run 被中止。 */
 export declare const INPUT_CANCELLED_TEXT = "The run was stopped while waiting for user input.";
+/**
+ * The result of an `AskUserQuestion` call whose question the user skipped by sending a message
+ * (reply-while-question spec §7.1): the message follows in the log as an ordinary user message.
+ */
+export declare const QUESTION_SKIPPED_TEXT = "The user did not answer this question and sent a message instead; read it below and continue.";
+/** The result of any other tool's input request (extension `input_required`, MCP elicitation) skipped by a message. */
+export declare const INPUT_SKIPPED_TEXT = "The user did not provide the requested input and sent a message instead; read it below and continue. Call the tool again only if it is still needed.";
 /** 同一调用连续请求输入超过上限。 */
 export declare const TOO_MANY_INPUT_REQUESTS_TEXT = "Tool requested user input too many times.";
 /** run 已被中止 / 到达截止时间，调用尚未开始执行。 */

package/dist/tools/pipeline.js

@@ -66,12 +66,38 @@ export const approvalExpiredText = (hours) => `Approval timed out after ${hours}
 export const APPROVAL_CANCELLED_TEXT = "The run was stopped while waiting for approval.";
 /** 等待用户输入期间 run 被中止。 */
 export const INPUT_CANCELLED_TEXT = "The run was stopped while waiting for user input.";
+/**
+ * The result of an `AskUserQuestion` call whose question the user skipped by sending a message
+ * (reply-while-question spec §7.1): the message follows in the log as an ordinary user message.
+ */
+export const QUESTION_SKIPPED_TEXT = "The user did not answer this question and sent a message instead; read it below and continue.";
+/** The result of any other tool's input request (extension `input_required`, MCP elicitation) skipped by a message. */
+export const INPUT_SKIPPED_TEXT = "The user did not provide the requested input and sent a message instead; read it below and continue. Call the tool again only if it is still needed.";
 /** 同一调用连续请求输入超过上限。 */
 export const TOO_MANY_INPUT_REQUESTS_TEXT = "Tool requested user input too many times.";
 /** run 已被中止 / 到达截止时间，调用尚未开始执行。 */
 export const RUN_STOPPED_TEXT = "The run was stopped before this tool call was executed.";
 /** 调用执行中 run 被中止 / 到达截止时间。 */
 export const RUN_STOPPED_DURING_TEXT = "The run was stopped while this tool call was running; its outcome is unknown. Verify before retrying.";
+/** The fixed result of a call whose input request was skipped by a message (spec §7.1). */
+const skippedResult = (toolKey) => toolKey === "AskUserQuestion"
+    ? {
+        content: QUESTION_SKIPPED_TEXT,
+        isError: false,
+        display: {
+            summary: {
+                zh: "用户没有回答，直接发了消息",
+                en: "User sent a message instead of answering",
+            },
+        },
+    }
+    : {
+        content: INPUT_SKIPPED_TEXT,
+        isError: true,
+        display: {
+            summary: { zh: "用户没有提供输入，直接发了消息", en: "User sent a message instead" },
+        },
+    };
 const timeoutText = (key, ms) => `Tool ${key} timed out after ${ms / 1000}s. The operation may or may not have completed; verify before retrying.`;
 const failedText = (key, errName) => `Tool ${key} failed (${errName}). The operation may not have completed; check before retrying or try another approach.`;
 /** The connector slugs and extension names among the run's tools (to read old `<x>__<tool>` keys). */
@@ -289,6 +315,12 @@ let ToolPipeline = class ToolPipeline {
         const last = rounds.at(-1);
         if (last?.status === "pending")
             return inputWait(last);
+        // skipped by the starter's message: the kernel writes the result, the tool is not called again
+        // (spec D6: an extension would only see `answer: null`, an MCP call would be re-sent)
+        if (last?.status === "skipped") {
+            await this.writeResult(ctx, call.id, last.toolKey, skippedResult(last.toolKey));
+            return undefined;
+        }
         const attempt = rounds.length + 1;
         const started = await this.deps.eventLog.findByIdem(ctx.conversationId, idem.started(ctx.runId, call.id, attempt));
         if (started?.type === "tool_call_started") {

package/dist/tools/questions.service.d.ts

@@ -4,7 +4,7 @@ import { KernelConfigService } from "../infra/config/kernel-config.service.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import { KernelEvents } from "../infra/events/kernel-events.js";
-export type QuestionStatus = "pending" | "answered" | "expired" | "cancelled";
+export type QuestionStatus = "pending" | "answered" | "skipped" | "expired" | "cancelled";
 /** 一条输入请求（`AskUserQuestion`、插件工具的 `input_required`、MCP elicitation 共用）。 */
 export interface QuestionRecord {
     id: string;
@@ -75,6 +75,13 @@ export declare class QuestionsService {
      * 传 `orgId` 时还要求输入请求属于该组织（HTTP 接口用）。
      */
     answer(questionId: string, accountId: string, answer: unknown, orgId?: string): Promise<QuestionRecord>;
+    /**
+     * Locks the conversation row of question `questionId` (`SELECT … FOR UPDATE`; re-entrant with the
+     * lock `EventLog.appendIn` takes later). Every write to a question row takes the conversation lock
+     * first, then the question row (reply-while-question spec §8.2, D7), as the message's skip and
+     * the stop of a waiting run do, so no two of them can deadlock. False: no such question (in `orgId`).
+     */
+    private lockConversationOf;
     private answerIn;
     /**
      * 超时（等待机制的超时任务调用）：仍 pending 且已到期 → 置 expired、写 `question_answered{expired}`。
@@ -99,6 +106,20 @@ export declare class QuestionsService {
         records: QuestionRecord[];
         seqs: Map<string, number>;
     }>;
+    /**
+     * Skips, in the caller's transaction (`mandatory`, the message's), every question a message by
+     * `accountId` just written at `messageSeq` closes (reply-while-question spec §4.2, §8.1): pending,
+     * not yet due, asked in `conversationId` (a sub-agent's question lives in the child conversation)
+     * by a run of it that is `running` or `waiting` and was started by `accountId`. The caller holds
+     * the conversation row lock (its `appendIn`), so only questions logged before the message are
+     * seen. Each becomes `skipped` with `question_answered { outcome: "skipped", skippedBySeq }`.
+     * Returns the records and the highest seq written (null: none); the caller notifies and emits
+     * `question.answered` after the commit.
+     */
+    skipPendingIn(conversationId: string, accountId: string, messageSeq: number): Promise<{
+        records: QuestionRecord[];
+        toSeq: number | null;
+    }>;
     /** `question_answered` in the current transaction; returns its seq. */
     private answeredEvent;
 }

package/dist/tools/questions.service.js

@@ -169,13 +169,38 @@ let QuestionsService = class QuestionsService {
             orgId: record.orgId,
             conversationId: record.conversationId,
             runId: record.runId,
+            outcome: "answered",
         });
         return record;
     }
+    /**
+     * Locks the conversation row of question `questionId` (`SELECT … FOR UPDATE`; re-entrant with the
+     * lock `EventLog.appendIn` takes later). Every write to a question row takes the conversation lock
+     * first, then the question row (reply-while-question spec §8.2, D7), as the message's skip and
+     * the stop of a waiting run do, so no two of them can deadlock. False: no such question (in `orgId`).
+     */
+    async lockConversationOf(questionId, orgId) {
+        const t = this.db.db;
+        let q = t.selectFrom("questions").select("conversation_id").where("id", "=", questionId);
+        if (orgId !== undefined)
+            q = q.where("org_id", "=", orgId);
+        const row = await q.executeTakeFirst();
+        if (!row)
+            return false;
+        await t
+            .selectFrom("conversations")
+            .select("id")
+            .where("id", "=", row.conversation_id)
+            .forUpdate()
+            .executeTakeFirst();
+        return true;
+    }
     // its own transaction (as the legacy one was): `question.answered` is emitted only after the
     // answer committed, even when a caller has a transaction open
     async answerIn(questionId, accountId, answer, orgId) {
         const t = this.db.db;
+        if (!(await this.lockConversationOf(questionId, orgId)))
+            throw notFound();
         let q = t
             .selectFrom("questions")
             .selectAll()
@@ -194,6 +219,9 @@ let QuestionsService = class QuestionsService {
         if (run?.trigger_account_id !== accountId)
             throw notInitiator();
         const before = toRecord(locked);
+        if (before.status === "skipped") {
+            throw new ApiError("question.already_answered", "Question was skipped: the user sent a message instead");
+        }
         if (before.status !== "pending") {
             throw new ApiError("question.already_answered", "Question has already been answered");
         }
@@ -233,6 +261,8 @@ let QuestionsService = class QuestionsService {
     }
     async expireIn(questionId) {
         const t = this.db.db;
+        if (!(await this.lockConversationOf(questionId)))
+            return { outcome: "settled" };
         const locked = await t
             .selectFrom("questions")
             .selectAll()
@@ -291,10 +321,33 @@ let QuestionsService = class QuestionsService {
      */
     async cancelPendingFor(orgId, accountId) {
         const t = this.db.db;
+        // the conversations first, in id order (lock order D7: conversation, then question rows)
+        const convs = await t
+            .selectFrom("questions")
+            .select("conversation_id")
+            .distinct()
+            .where("org_id", "=", orgId)
+            .where("status", "=", "pending")
+            .where("run_id", "in", (eb) => eb.selectFrom("runs").select("id").where("trigger_account_id", "=", accountId))
+            .execute();
+        if (convs.length > 0) {
+            await t
+                .selectFrom("conversations")
+                .select("id")
+                .where("id", "in", convs.map((c) => c.conversation_id))
+                .orderBy("id")
+                .forUpdate()
+                .execute();
+        }
+        // only the conversations locked above: a question asked meanwhile in another one waits for
+        // the run's stop (offboarding aborts it) or the sweep, so no conversation is locked after a row
+        if (convs.length === 0)
+            return { records: [], seqs: new Map() };
         const rows = await t
             .selectFrom("questions")
             .selectAll()
             .where("org_id", "=", orgId)
+            .where("conversation_id", "in", convs.map((c) => c.conversation_id))
             .where("status", "=", "pending")
             .where("run_id", "in", (eb) => eb.selectFrom("runs").select("id").where("trigger_account_id", "=", accountId))
             .orderBy("created_at")
@@ -315,14 +368,60 @@ let QuestionsService = class QuestionsService {
         }
         return { records, seqs };
     }
+    /**
+     * Skips, in the caller's transaction (`mandatory`, the message's), every question a message by
+     * `accountId` just written at `messageSeq` closes (reply-while-question spec §4.2, §8.1): pending,
+     * not yet due, asked in `conversationId` (a sub-agent's question lives in the child conversation)
+     * by a run of it that is `running` or `waiting` and was started by `accountId`. The caller holds
+     * the conversation row lock (its `appendIn`), so only questions logged before the message are
+     * seen. Each becomes `skipped` with `question_answered { outcome: "skipped", skippedBySeq }`.
+     * Returns the records and the highest seq written (null: none); the caller notifies and emits
+     * `question.answered` after the commit.
+     */
+    async skipPendingIn(conversationId, accountId, messageSeq) {
+        const t = this.db.db;
+        const rows = await t
+            .selectFrom("questions as q")
+            .innerJoin("runs as r", "r.id", "q.run_id")
+            .selectAll("q")
+            .where("q.conversation_id", "=", conversationId)
+            .where("q.status", "=", "pending")
+            .where(sql `q.expires_at > now()`)
+            .where("r.status", "in", ["running", "waiting"])
+            .where("r.trigger_account_id", "=", accountId)
+            .orderBy("q.created_at")
+            .orderBy("q.id")
+            .forUpdate("q")
+            .execute();
+        const records = [];
+        let toSeq = null;
+        for (const row of rows) {
+            const updated = await t
+                .updateTable("questions")
+                .set({ status: "skipped", answered_by: accountId, answered_at: sql `now()` })
+                .where("id", "=", row.id)
+                .returningAll()
+                .executeTakeFirstOrThrow();
+            toSeq = await this.answeredEvent(toRecord(row), null, accountId, "skipped", messageSeq);
+            records.push(toRecord(updated));
+        }
+        return { records, toSeq };
+    }
     /** `question_answered` in the current transaction; returns its seq. */
-    async answeredEvent(q, answer, byAccountId, outcome) {
+    async answeredEvent(q, answer, byAccountId, outcome, skippedBySeq) {
         const written = await this.eventLog.appendIn(q.conversationId, [
             {
                 type: "question_answered",
                 runId: q.runId,
                 idemKey: `question_answered:${q.id}`,
-                payload: { questionId: q.id, callId: q.callId, answer, byAccountId, outcome },
+                payload: {
+                    questionId: q.id,
+                    callId: q.callId,
+                    answer,
+                    byAccountId,
+                    outcome,
+                    ...(skippedBySeq !== undefined && { skippedBySeq }),
+                },
             },
         ]);
         return Math.max(...written.map((e) => e.seq));
@@ -343,6 +442,9 @@ __decorate([
 __decorate([
     Transactional({ propagation: "mandatory" })
 ], QuestionsService.prototype, "cancelPendingFor", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], QuestionsService.prototype, "skipPendingIn", null);
 QuestionsService = __decorate([
     Injectable(),
     __param(0, Inject(KernelDb)),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capybara-hq/kernel",
-  "version": "0.1.0-rc.15",
+  "version": "0.1.0-rc.17",
   "description": "Capybara kernel: config, database, plugin host and HTTP API of the Capybara agent platform",
   "license": "Apache-2.0",
   "repository": {
@@ -65,7 +65,7 @@
     "yaml": "^2.9.1",
     "yauzl": "3.4.0",
     "zod": "^4.6.7",
-    "@capybara-hq/plugin-sdk": "^0.1.0-rc.11"
+    "@capybara-hq/plugin-sdk": "^0.1.0-rc.13"
   },
   "devDependencies": {
     "@langchain/langgraph-checkpoint-validation": "^1.2.0",
@@ -74,7 +74,7 @@
     "@types/ws": "^8.18.2",
     "@types/yauzl": "3.4.0",
     "ws": "^8.22.0",
-    "@capybara-hq/testing": "0.1.0-rc.14"
+    "@capybara-hq/testing": "0.1.0-rc.15"
   },
   "scripts": {
     "build": "tsc -b"

package/src/migrations/0108_question_skipped.sql

@@ -0,0 +1,6 @@
+-- A message from the run's starter closes a pending question as skipped (reply-while-question spec
+-- §6.2). Widening the inline CHECK of 0010 (PG's default name questions_status_check): drop and add
+-- in the file's one transaction, idempotent.
+ALTER TABLE questions DROP CONSTRAINT IF EXISTS questions_status_check;
+ALTER TABLE questions ADD CONSTRAINT questions_status_check
+  CHECK (status IN ('pending', 'answered', 'skipped', 'expired', 'cancelled'));