maka-agent 0.2.1-dev.90.20261017 → 0.2.1-dev.91.20261018

package/node_modules/@maka/core/dist/runtime-event.js

@@ -173,6 +173,7 @@ export function runtimeEventEnvelopeValueDomains() {
 }
 const RUNTIME_EVENT_SHAPE = defineObjectShape()(['id', 'invocationId', 'runId', 'sessionId', 'turnId', 'ts', 'partial', 'role', 'author'], ['branch', 'origin', 'modelVisibility', 'status', 'content', 'actions', 'refs']);
 const TEXT_CONTENT_SHAPE = defineObjectShape()(['kind', 'text'], [
+    'summary',
     'displayText',
     'interrupted',
     'origin',
@@ -377,6 +378,7 @@ export function decodeRuntimeEvent(value) {
             content: {
                 kind: 'text',
                 ...normalizeMessageContent(value.content),
+                ...(value.content.summary !== undefined ? { summary: value.content.summary } : {}),
                 ...(value.content.origin !== undefined
                     ? { origin: decodeTurnOrigin(value.content.origin) }
                     : {}),
@@ -403,6 +405,7 @@ function isRuntimeEventContent(value) {
     switch (value.kind) {
         case 'text':
             if (!hasExactShape(value, TEXT_CONTENT_SHAPE) ||
+                (value.summary !== undefined && typeof value.summary !== 'string') ||
                 (value.origin !== undefined && !isTurnOrigin(value.origin)) ||
                 (value.steering !== undefined && value.steering !== true) ||
                 (value.interrupted !== undefined && value.interrupted !== true) ||

package/node_modules/@maka/core/dist/session.js

@@ -393,7 +393,7 @@ const USER_MESSAGE_SHAPE = defineObjectShape()(['type', 'id', 'turnId', 'ts', 't
     'coordinationActionId',
     'origin',
 ]);
-const ASSISTANT_MESSAGE_SHAPE = defineObjectShape()(['type', 'id', 'turnId', 'ts', 'text', 'modelId'], ['thinking', 'contentOrder', 'providerOptions', 'interrupted']);
+const ASSISTANT_MESSAGE_SHAPE = defineObjectShape()(['type', 'id', 'turnId', 'ts', 'text', 'modelId'], ['thinking', 'contentOrder', 'providerOptions', 'interrupted', 'summary']);
 const TOOL_CALL_MESSAGE_SHAPE = defineObjectShape()(['type', 'id', 'turnId', 'ts', 'toolName', 'args'], [
     'activityKind',
     'displayName',
@@ -610,6 +610,7 @@ function decodeMessage(value, decodeToolResultContent) {
                 hasMessageEnvelope(message, true) &&
                 typeof message.text === 'string' &&
                 typeof message.modelId === 'string' &&
+                (message.summary === undefined || typeof message.summary === 'string') &&
                 (message.interrupted === undefined || message.interrupted === true) &&
                 (message.providerOptions === undefined || isRecord(message.providerOptions)) &&
                 (message.thinking === undefined || isAssistantThinking(message.thinking)) &&

package/node_modules/@maka/core/dist/turn-origin.js

@@ -17,6 +17,7 @@
  * under the License.
  */
 import { defineObjectShape, hasExactShape, isRecord } from './record-schema.js';
+const EXTERNAL_CONNECTOR_ORIGIN_SHAPE = defineObjectShape()(['kind', 'connectorId'], ['senderId']);
 const SCHEDULED_TASK_ORIGIN_SHAPE = defineObjectShape()(['kind', 'scheduledTaskId'], []);
 const CLOUD_ACTIVATION_ORIGIN_SHAPE = defineObjectShape()(['kind', 'activationId'], []);
 const LEGACY_AUTOMATION_ORIGIN_SHAPE = defineObjectShape()(['kind', 'automationId'], []);
@@ -26,6 +27,19 @@ const AGENT_GRAPH_ORIGIN_SHAPE = defineObjectShape()(['kind', 'graphId', 'wakeId
 export function decodeTurnOrigin(value) {
     if (!isRecord(value))
         return undefined;
+    if (value.kind === 'external_connector') {
+        if (!hasExactShape(value, EXTERNAL_CONNECTOR_ORIGIN_SHAPE) ||
+            typeof value.connectorId !== 'string' ||
+            !value.connectorId.length ||
+            (value.senderId !== undefined &&
+                (typeof value.senderId !== 'string' || !value.senderId.length)))
+            return undefined;
+        return {
+            kind: 'external_connector',
+            connectorId: value.connectorId,
+            ...(value.senderId !== undefined ? { senderId: value.senderId } : {}),
+        };
+    }
     if (value.kind === 'workhub_result') {
         const keys = ['kind', 'eventId', 'actionId', 'delegationId', 'targetSessionId', 'targetTurnId'];
         if (Object.keys(value).length !== keys.length ||

package/node_modules/@maka/runtime/dist/ai-sdk-turn.js

@@ -1748,6 +1748,7 @@ export class AiSdkTurn {
                         throw providerOutcome.failure;
                     finishReason = providerOutcome.finishReason;
                     await queue.waitUntilConsumedThroughCurrent();
+                    let toolRequestedFinish = false;
                     if (returnedToolCalls.length > 0) {
                         const continuationBudgetRemains = maxSteps === undefined || runtimeSteps < maxSteps;
                         if (continuationBudgetRemains && !this.deps.backend.loadTurnRuntimeEvents) {
@@ -1819,6 +1820,12 @@ export class AiSdkTurn {
                                 throw outcome.reason;
                             const settlement = outcome.value;
                             const toolCall = returnedToolCalls[index];
+                            const definition = toolCall && toolsByName.get(toolCall.toolName);
+                            if (returnedToolCalls.length === 1 &&
+                                definition?.executionSemantics === 'exclusive_step' &&
+                                definition.finishTurnOnSuccess &&
+                                !settlement.providerError)
+                                toolRequestedFinish = true;
                             if (isPlanToolResult(settlement.result)) {
                                 this.handlePlanToolResult(settlement.result, queue);
                             }
@@ -1851,6 +1858,21 @@ export class AiSdkTurn {
                         ...(providerStepUsage ? { usage: providerStepUsage } : {}),
                     });
                     lastCompletedStepHadToolResult = returnedToolCalls.length > 0;
+                    // Finish only after the tool result is durably consumed. The Host can
+                    // veto completion (for example, new Inbox input raced with Sleep).
+                    if (toolRequestedFinish && !this.aborted && !this.loopStopRequested) {
+                        const decision = await this.deps.backend.beforeTurnFinish?.({
+                            sessionId: this.deps.backend.sessionId,
+                            turnId,
+                            signal: turnAbortController.signal,
+                        });
+                        if (!decision || decision.allow) {
+                            finishReason = 'stop';
+                            this.deps.modelAdapter.clearContinuation(this.turnId);
+                            break agentLoop;
+                        }
+                        finishFeedback = decision.feedback;
+                    }
                     const stepLimitReached = maxSteps !== undefined && runtimeSteps >= maxSteps;
                     if (sandboxBoundaryFinalizationStep ||
                         (stepLimitReached &&

package/node_modules/@maka/runtime/dist/plugin-agent-service.js

@@ -100,7 +100,13 @@ export class PluginAgentService extends Service {
         return Object.freeze({
             ...descriptor,
             id,
-            followup: (message) => service.runtime().followup(id, message, invocation),
+            followup: (message, options) => service.runtime().followup(id, message, invocation, options),
+            messageExecution: async (messageId) => {
+                const runtime = service.runtime();
+                if (!runtime.messageExecution)
+                    throw new Error('Runtime message execution query unavailable');
+                return runtime.messageExecution(id, messageId, invocation);
+            },
             steer: (message) => service.runtime().steer(id, message, invocation),
             inject: (message) => service.runtime().inject(id, message, invocation),
             cancel: () => service.runtime().cancel(id, invocation),

package/node_modules/@maka/runtime/dist/runtime-event-backfill.js

@@ -90,6 +90,7 @@ export function backfillRuntimeEventsFromStoredMessages(input) {
                         content: {
                             kind: 'text',
                             text: message.text,
+                            ...(message.summary !== undefined ? { summary: message.summary } : {}),
                             ...(message.interrupted ? { interrupted: true } : {}),
                         },
                         actions: { stateDelta: recoveryState(now, message) },

package/node_modules/@maka/runtime/dist/runtime-event-read-model.js

@@ -659,6 +659,7 @@ function projectText(event, state, messages) {
             turnId: event.turnId,
             ts: event.ts,
             text: event.content.text,
+            ...(event.content.summary !== undefined ? { summary: event.content.summary } : {}),
             ...(event.content.interrupted ? { interrupted: true } : {}),
             ...(event.content.providerOptions !== undefined
                 ? { providerOptions: structuredClone(event.content.providerOptions) }

package/node_modules/@maka/runtime-host/dist/assistant/bot/avatar.js

@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { validateImageBytes } from '@maka/runtime/image-file';
+import { assistantAvatarSchema, assistantEmojiSchema, DEFAULT_ASSISTANT_AVATAR, } from '../../protocol/personal-assistant.js';
+export function initializeAvatar(ctx, store, bot, register) {
+    const current = () => store.get('avatar');
+    const avatar = () => {
+        const { imageData: _, ...metadata } = current() ?? {};
+        return assistantAvatarSchema.safeParse(metadata).data ?? DEFAULT_ASSISTANT_AVATAR;
+    };
+    ctx.api.register('assistant.avatar', () => ({ avatar: avatar() }));
+    // Bounded transfers keep large images out of the normal status polling and model transcript.
+    ctx.api.register('assistant.avatar-image', (raw) => {
+        const { id, offset } = z
+            .object({ id: z.string(), offset: z.number().int().nonnegative().default(0) })
+            .parse(raw);
+        const saved = current();
+        if (avatar().image?.id !== id || !saved?.imageData)
+            throw Error('Avatar changed; refresh its metadata');
+        if (offset >= saved.imageData.length)
+            throw Error('Invalid avatar offset');
+        const data = saved.imageData.slice(offset, offset + 192 * 1024);
+        return {
+            id,
+            offset,
+            data,
+            nextOffset: offset + data.length < saved.imageData.length ? offset + data.length : null,
+        };
+    });
+    register('AssistantSetAvatar', '更换你自己的头像，入口和聊天消息同步显示，重启后保留。image 填生成或找到的图片的当前工具会话工作目录内的本地路径或公网 HTTP(S) 图片网址（PNG/JPEG/WebP/GIF，最多 2 MiB），不要传 base64。也可用 emoji 填一个 emoji；两者选一。background 可填 #RRGGBB。图片会保存副本；此工具只设置头像，生成或找图使用已有工具，必要时委派任务。不会发送消息。', z
+        .object({
+        emoji: assistantEmojiSchema.optional(),
+        image: z.string().trim().min(1).max(8192).optional(),
+        background: z
+            .string()
+            .regex(/^#[0-9a-fA-F]{6}$/)
+            .default('#E5EDFF'),
+    })
+        .strict()
+        .refine((value) => Boolean(value.emoji) !== Boolean(value.image), 'Provide exactly one of emoji or image'), async (input, call) => {
+        let saved;
+        if (input.image) {
+            if (!ctx.readAvatarImage)
+                throw Error('Image loading is unavailable on this Host');
+            const worker = bot.worker();
+            const owner = bot.owner();
+            const result = await ctx.readAvatarImage(call.sessionId, input.image, call.abortSignal);
+            call.abortSignal.throwIfAborted();
+            bot.ready();
+            if (bot.worker() !== worker || bot.owner() !== owner)
+                throw Error('Assistant binding changed');
+            const image = validateImageBytes(result.bytes, 'chat');
+            const bytes = Buffer.from(image.bytes);
+            const imageData = bytes.toString('base64');
+            saved = {
+                background: input.background,
+                image: {
+                    id: createHash('sha256').update(bytes).digest('hex'),
+                    mimeType: image.mimeType,
+                    length: imageData.length,
+                },
+                imageData,
+            };
+        }
+        else
+            saved = { emoji: input.emoji, background: input.background };
+        // One SQLite value makes image content and metadata an atomic replacement.
+        store.set('avatar', saved);
+        return { updated: true, avatar: avatar() };
+    });
+}

package/node_modules/@maka/runtime-host/dist/assistant/bot/bridge.js

@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/** In-process routing only; durable mailbox and wake state belong to the Bot. */
+export class AssistantBotBridge {
+    endpoint;
+    register(endpoint) {
+        this.endpoint = endpoint;
+    }
+    status() {
+        return this.endpoint?.status() ?? null;
+    }
+    isConversation(id) {
+        return this.endpoint?.owner() === id;
+    }
+    hasUserMessage(sessionId, id) {
+        return this.isConversation(sessionId) && this.endpoint.hasUserMessage(id);
+    }
+    isWorker(id) {
+        return this.endpoint?.worker() === id;
+    }
+    ownerFor(id) {
+        return this.isWorker(id) ? this.endpoint?.owner() : undefined;
+    }
+    async receive(sessionId, id, content, origin) {
+        if (!this.isConversation(sessionId))
+            return false;
+        await this.endpoint.receive(id, content, origin);
+        return true;
+    }
+    post(owner, input) {
+        if (!this.isConversation(owner))
+            return false;
+        this.endpoint.post(input);
+        return true;
+    }
+}

package/node_modules/@maka/runtime-host/dist/assistant/bot/capabilities.js

@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+export const BOT_TOOLS = new Set([
+    'InboxList',
+    'InboxRead',
+    'InboxCheck',
+    'SendUser',
+    'AssistantSetAvatar',
+    'Sleep',
+    'AssistantConversation',
+    'MatterDelegate',
+    'MatterTasks',
+    'MatterTaskMessage',
+    'MatterReply',
+    'MatterTaskControl',
+    'MatterDelegationRecover',
+    'MatterFeedbackRetry',
+    'InitiativeEnable',
+    'InitiativeConfigure',
+    'InitiativeControl',
+    'InitiativeStatus',
+    'MemoryIndexCreate',
+    'MemoryIndexCreateGroup',
+    'MemoryIndexMaintain',
+    'MemoryIndexControl',
+    'MemoryIndexAddSources',
+    'MemoryIndexList',
+    'MemoryIndexRead',
+    'MemoryIndexContent',
+    'MemoryIndexLinks',
+    'MemoryOriginal',
+    'MemoryHistory',
+    'MemorySources',
+    'MemoryRange',
+]);
+export const BOT_DELEGATION_TOOLS = new Set([...BOT_TOOLS].filter((name) => name.startsWith('Matter') || name.startsWith('Initiative') || name.startsWith('Memory')));

package/node_modules/@maka/runtime-host/dist/assistant/bot/controller.js

@@ -0,0 +1,300 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { randomUUID } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+import { ASSISTANT_BACKGROUND_SESSION_LABEL } from '@maka/core/session';
+const UNREAD_SLEEP_FEEDBACK = '本次未能休眠：你读取 Inbox 后又收到新消息，或上一批还有未投递消息。请调用 InboxCheck 接收正文，再自行决定如何处理；不要求回复或完成每件事，之后可再次调用 Sleep。';
+export class BotController {
+    ctx;
+    binding;
+    store;
+    abort = new AbortController();
+    timer;
+    running;
+    flushing;
+    activeAgent;
+    deliveredThrough = 0;
+    deliveries = new Map();
+    checkInbox(callId, limit) {
+        this.ready();
+        const previous = this.deliveries.get(callId);
+        if (previous)
+            return previous;
+        const batch = this.store.batch(this.deliveredThrough, limit);
+        this.deliveredThrough = batch.through;
+        this.deliveries.set(callId, batch);
+        return batch;
+    }
+    isWorking() {
+        return !!this.activeAgent && !this.store.get('sleepTurn') && !this.store.get('error');
+    }
+    isSleeping() {
+        return (!this.running &&
+            !this.store.get('error') &&
+            this.store.head() <= (this.store.get('deliveredThrough') ?? 0));
+    }
+    constructor(ctx, binding, store) {
+        this.ctx = ctx;
+        this.binding = binding;
+        this.store = store;
+    }
+    owner() {
+        return this.binding.get()?.sessionId;
+    }
+    worker() {
+        return this.store.get('worker');
+    }
+    invocation(sessionId = this.owner()) {
+        return {
+            sessionId,
+            cwd: this.binding.get().cwd,
+            emitOutput: () => { },
+            turnId: 'assistant-bot',
+            toolCallId: randomUUID(),
+            abortSignal: this.abort.signal,
+        };
+    }
+    start() {
+        this.timer = setInterval(() => this.tick(), 1000);
+        this.timer.unref?.();
+        this.tick();
+    }
+    ready() {
+        this.abort.signal.throwIfAborted();
+        this.binding.fence();
+    }
+    post(input) {
+        this.ready();
+        this.store.post(input);
+        this.tick();
+    }
+    async receive(id, content, origin) {
+        this.ready();
+        this.store.post({
+            id,
+            type: 'user_message',
+            source: origin ? 'external_connector' : 'user',
+            content: origin ? { ...content, origin } : content,
+        }, {
+            ...content,
+            type: 'user',
+            ...(origin ? { origin } : {}),
+            id,
+            turnId: `assistant-input:${id}`,
+            ts: Date.now(),
+        });
+        await this.flush();
+        this.tick();
+    }
+    async flush() {
+        if (this.flushing) {
+            await this.flushing;
+            if (this.store.pendingVisible().length)
+                await this.flush();
+            return;
+        }
+        this.flushing = (async () => {
+            for (const message of this.store.pendingVisible()) {
+                this.ready();
+                if (!this.ctx.appendConversation)
+                    throw Error('Assistant conversation transport unavailable');
+                await this.ctx.appendConversation(this.owner(), message);
+                this.store.delivered(message.id);
+            }
+        })().finally(() => {
+            this.flushing = undefined;
+        });
+        return this.flushing;
+    }
+    async agent() {
+        return this.ctx.agents.withInvocation(this.invocation(), async () => {
+            let id = this.worker();
+            if (!id) {
+                const label = `assistant-bot:${this.owner()}`;
+                const matches = (await this.ctx.sessionQuery.list()).filter((s) => s.labels?.includes(label));
+                if (matches.length > 1)
+                    throw Error('Multiple Bot workers found; cannot choose a conversation');
+                id = matches[0]?.id;
+                if (!id)
+                    id = (await this.ctx.agents.create({
+                        background: true,
+                        name: '个人助手 · Bot',
+                        labels: [label, ASSISTANT_BACKGROUND_SESSION_LABEL],
+                    })).sessionId;
+                this.store.set('worker', id);
+            }
+            return this.ctx.agents.resume({ sessionId: id });
+        });
+    }
+    tick() {
+        if (this.running || this.abort.signal.aborted || !this.owner())
+            return;
+        try {
+            this.ready();
+        }
+        catch {
+            return;
+        }
+        this.running = this.run()
+            .catch((error) => {
+            if (!this.abort.signal.aborted)
+                this.store.set('error', String(error));
+        })
+            .finally(() => {
+            this.running = undefined;
+        });
+    }
+    async run() {
+        await this.flush();
+        if (this.store.get('error'))
+            return;
+        if (this.store.head() <= (this.store.get('deliveredThrough') ?? 0)) {
+            this.store.set('wake', null);
+            this.store.set('wakeError', null);
+            return;
+        }
+        // Commit delivery only at a normal Sleep boundary. An interrupted loop may
+        // replay mail, but cannot lose it between a tool return and durable history.
+        this.deliveredThrough = this.store.get('deliveredThrough') ?? 0;
+        this.deliveries.clear();
+        const agent = await this.agent();
+        this.activeAgent = agent;
+        try {
+            const status = (await agent.snapshot())?.agent?.status;
+            if (['blocked', 'waiting_for_user'].includes(status))
+                throw Error('Bot requires attention in its worker Session');
+            let wake = this.store.get('wake');
+            if (wake || status !== 'running') {
+                if (!wake) {
+                    this.store.set('sleepTurn', null);
+                    wake = {
+                        messageId: randomUUID(),
+                        text: `Inbox 有新消息。当前 UTC 时间：${new Date().toISOString()}。用 InboxCheck 批量接收新消息正文，自主决定如何处理；不需要轮询。`,
+                    };
+                    // Persist before submission: an ambiguous response must not create another wake.
+                    this.store.set('wake', wake);
+                }
+                for (;;) {
+                    this.ready();
+                    let resolution;
+                    try {
+                        resolution = await agent.messageExecution(wake.messageId);
+                        if (resolution?.state === 'not_admitted') {
+                            const admitted = await agent.followup(wake.text, { messageId: wake.messageId });
+                            if (!['turn_started', 'followup'].includes(admitted?.disposition))
+                                throw Error('Bot wake was not admitted');
+                            if (admitted.disposition === 'turn_started') {
+                                this.store.set('wakeError', null);
+                                break;
+                            }
+                        }
+                    }
+                    catch (error) {
+                        // Retry reconciliation on the next scheduler tick, keeping the submission identity.
+                        this.store.set('wakeError', String(error));
+                        return;
+                    }
+                    this.store.set('wakeError', null);
+                    if (resolution?.state === 'owned') {
+                        const currentStatus = (await agent.snapshot())?.agent?.status;
+                        if (!this.store.get('sleepTurn') &&
+                            ['idle', 'active', 'aborted'].includes(currentStatus)) {
+                            // An admitted wake can outlive its interrupted execution. Keep its
+                            // history, but persist a fresh identity before resuming unread mail.
+                            wake = { ...wake, messageId: randomUUID() };
+                            this.store.set('wake', wake);
+                            continue;
+                        }
+                        break;
+                    }
+                    // Pending submissions may deliberately be omitted from query results.
+                    if (!resolution) {
+                        await delay(1000, undefined, { signal: this.abort.signal });
+                        continue;
+                    }
+                    if (resolution?.state === 'cancelled') {
+                        this.store.set('wake', null);
+                        throw Error('Bot wake was cancelled; Inbox is preserved');
+                    }
+                    if (!['pending', 'not_admitted'].includes(resolution?.state))
+                        throw Error('Unexpected Bot wake execution state: ' + resolution?.state);
+                    await delay(1000, undefined, { signal: this.abort.signal });
+                }
+            }
+            try {
+                await agent.whenIdle(this.abort.signal);
+            }
+            catch (error) {
+                // A failed execution is terminal; a failed observation is not.
+                if (!this.abort.signal.aborted) {
+                    const stopped = (await agent.snapshot())?.agent?.status;
+                    if (['active', 'idle', 'aborted'].includes(stopped))
+                        this.store.set('wake', null);
+                }
+                throw error;
+            }
+            const finalStatus = (await agent.snapshot())?.agent?.status;
+            this.store.set('wake', null);
+            if (['aborted', 'blocked', 'waiting_for_user'].includes(finalStatus))
+                throw Error('Bot stopped: ' + finalStatus);
+            if (!this.store.get('sleepTurn'))
+                throw Error('Bot ended without Sleep; send a new message to retry');
+        }
+        finally {
+            this.activeAgent = undefined;
+        }
+    }
+    sleep(turnId) {
+        this.ready();
+        if (this.store.head() > this.deliveredThrough) {
+            this.store.set('sleepTurn', null);
+            return { sleeping: false, notice: UNREAD_SLEEP_FEEDBACK };
+        }
+        this.store.transaction(() => {
+            this.store.set('sleepThrough', this.deliveredThrough);
+            this.store.set('sleepTurn', turnId);
+        });
+        return {
+            sleeping: true,
+            notice: '本轮停止工作；新消息将唤醒你。已投递消息仍可回查，不会因未回复而重复唤醒。',
+        };
+    }
+    beforeFinish(turnId) {
+        this.ready();
+        if (this.store.get('sleepTurn') === turnId &&
+            this.store.head() <= (this.store.get('sleepThrough') ?? 0)) {
+            this.store.set('deliveredThrough', this.deliveredThrough);
+            return { allow: true };
+        }
+        this.store.set('sleepTurn', null);
+        return {
+            allow: false,
+            feedback: this.store.head() > this.deliveredThrough
+                ? UNREAD_SLEEP_FEEDBACK
+                : '你是 Inbox 驱动的 Bot。普通文本不会发送给用户，也不会让你休眠。需要交流用 SendUser，无需继续时调用 Sleep。若 Inbox 还有未投递消息，用 InboxCheck 接收正文后自行决定如何处理；读取不要求回复或完成事情。',
+        };
+    }
+    async close() {
+        clearInterval(this.timer);
+        this.abort.abort(Error('Assistant Bot stopped'));
+        if (this.activeAgent)
+            await this.activeAgent.cancel();
+        await Promise.allSettled([this.running, this.flushing].filter(Boolean));
+    }
+}