@capybara-hq/kernel 0.1.0-rc.16 → 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.12";
+    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/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/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.16",
+  "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.12"
+    "@capybara-hq/plugin-sdk": "^0.1.0-rc.13"
   },
   "devDependencies": {
     "@langchain/langgraph-checkpoint-validation": "^1.2.0",

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'));