@khorsheed/dsh-room 0.2.3 → 0.2.5

package/lib/types/index.js

@@ -32,6 +32,58 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     if (target) Object.defineProperty(target, contextIn.name, descriptor);
     done = true;
 };
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
     if (typeof path === "string" && /^\.\.?\//.test(path)) {
         return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
@@ -87,7 +139,7 @@ import { composeRoomAgent, deriveSessionPreset, probeAgentPresets, inspectCold,
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import { probeLocalAgent, probeLocalAgentRoster } from './adapter.js';
-import { DispatchEngine, heldReportsText, isRoomSource, roomSource, runChildSessionId, runChildTurn } from './dispatch.js';
+import { BEFORE_TAIL, DispatchEngine, MERGED_BACKLOG_TEXT, roundTextSoFar, MOVED_ON_TEXT, floatRunningCards, heldReportsText, isRoomSource, roomSource, runChildSessionId, runChildTurn } from './dispatch.js';
 import { coordinatorMember, DEFAULT_ROOM_SETTINGS, memberId, isRoomLog, MAIN_AGENT_MEMBER, parseMentions, replay, ROOM_EVENT_TYPES, ROOM_ROLE_MAX } from './journal.js';
 import { messageId, parseMessageRef, releaseIntent, SELF_TASK, sendOrHold, workingHop } from './messaging.js';
 import { isHumanMessage, linkedTask, taskLinks } from './deliveries.js';
@@ -155,6 +207,43 @@ export function parseQuestions(raw) {
         return 'Question ids must be unique';
     return questions;
 }
+/**
+ * The message a late answer reaches its member as: each question with the
+ * human's pick, so the member can go on (or correct what it assumed).
+ * @param questions - the card's questions.
+ * @param answers - the human's answers, one per question.
+ * @returns the dispatch text.
+ */
+export function lateAnswerText(questions, answers) {
+    const lines = questions.map((question) => {
+        const answer = answers.find(entry => entry.id === question.id);
+        const picked = [...answer?.selected ?? [], ...answer?.custom === undefined ? [] : [answer.custom]].join('；');
+        return `- ${question.header === undefined ? '' : `${question.header}：`}${question.question} → ${picked === '' ? '（没选）' : picked}`;
+    });
+    return [
+        '你之前用 ask_user_question 问的问题没等到回答就过期了，人现在补答了：',
+        ...lines,
+        '',
+        '按这些答案继续。如果你已经按自己的假设往下做了，对照答案调整，并说一下改了什么。',
+    ].join('\n');
+}
+/**
+ * The dispatch text with the message's attachments appended as local paths:
+ * every member — CLI or native — opens them with its own read tool, so one
+ * form reaches all of them.
+ * @param text - the dispatched text.
+ * @param attachments - the admitted attachments.
+ * @returns the text members receive.
+ */
+export function withAttachmentPaths(text, attachments) {
+    if (attachments === undefined || attachments.length === 0)
+        return text;
+    const lines = attachments.map((entry) => {
+        const label = `${entry.kind === 'image' ? '图片' : '文件'}${entry.name === undefined ? '' : ` ${entry.name}`}`;
+        return `- ${label}：${entry.path ?? '（宿主没有给出本地路径，打不开就告诉人）'}`;
+    });
+    return [text, '', '人随消息附了这些附件，用你自己的读取工具打开（图片用能看图的读取工具）：', ...lines].join('\n');
+}
 function messageReceipt(receipt, kind) {
     if (receipt.held !== undefined) {
         const why = receipt.held === 'paused' ? '房间已暂停，恢复后自动投递'
@@ -205,6 +294,7 @@ export function handoffText(_events, state, sessionId, from, to) {
 let RoomService = (() => {
     let _classSuper = TypertRemoteService;
     let _instanceExtraInitializers = [];
+    let _pendingCards_decorators;
     let _isRoom_decorators;
     let _listProviders_decorators;
     let _setTaskHint_decorators;
@@ -234,6 +324,7 @@ let RoomService = (() => {
     return class RoomService extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _pendingCards_decorators = [Remote('pendingCards')];
             _isRoom_decorators = [Remote('isRoom')];
             _listProviders_decorators = [Remote('listProviders')];
             _setTaskHint_decorators = [Remote('setTaskHint')];
@@ -260,6 +351,7 @@ let RoomService = (() => {
             _setGoal_decorators = [Remote('setGoal')];
             _cancel_decorators = [Remote('cancel')];
             _cancelChild_decorators = [Remote('cancelChild')];
+            __esDecorate(this, null, _pendingCards_decorators, { kind: "method", name: "pendingCards", static: false, private: false, access: { has: obj => "pendingCards" in obj, get: obj => obj.pendingCards }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _isRoom_decorators, { kind: "method", name: "isRoom", static: false, private: false, access: { has: obj => "isRoom" in obj, get: obj => obj.isRoom }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _listProviders_decorators, { kind: "method", name: "listProviders", static: false, private: false, access: { has: obj => "listProviders" in obj, get: obj => obj.listProviders }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _setTaskHint_decorators, { kind: "method", name: "setTaskHint", static: false, private: false, access: { has: obj => "setTaskHint" in obj, get: obj => obj.setTaskHint }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -421,6 +513,15 @@ let RoomService = (() => {
                 }
                 return { kind: 'enter', messages: [] };
             });
+            // The session list's status (the host shows a session running only while
+            // its own agent runs): a room is running while any member runs, and its
+            // waiting question/approval cards are tracked for the browser.
+            ctx.on('session/event', (session, event) => { this.observeActivity(session, event); });
+            ctx.on('agent/status', ({ agent, status }) => {
+                // The room's own agent settling must not hide members still at work.
+                if (status !== 'running' && (this.activeRuns.get(String(agent.id))?.size ?? 0) > 0)
+                    this.emitStatus(String(agent.id), true);
+            });
             // Cross-session help (help.ts): a help message reaching a helper's turn
             // equips that agent with the helper tools and marks the thread running;
             // an agent whose log already holds help requests (a restart dropped its
@@ -541,6 +642,95 @@ let RoomService = (() => {
          * @param request - session identity.
          * @returns true when the session carries the marker (false for unknown sessions too).
          */
+        /** Run ids of the members working in each room (the session list's 运行中). */
+        activeRuns = new Map();
+        /** Question/approval cards waiting for the human, per room. */
+        waitingCards = new Map();
+        /**
+         * Follow a room's run and card edges as they are journaled: a room turns
+         * running when its first member starts and settles when its last one ends
+         * (the host's `api-session/status`, so the list shows 运行中 and then
+         * 已完成), and its waiting cards are kept for {@link pendingCards}.
+         * @param session - the session the event landed in.
+         * @param event - the journaled event.
+         */
+        observeActivity(session, event) {
+            const id = String(session.id);
+            switch (event.type) {
+                case 'room/run-state': {
+                    const runs = this.activeRuns.get(id) ?? new Set();
+                    const before = runs.size;
+                    const key = event.data.runId ?? `${event.data.member}:${event.data.startedAt}`;
+                    if (event.data.state === 'running')
+                        runs.add(key);
+                    else
+                        runs.delete(key);
+                    if (runs.size === 0)
+                        this.activeRuns.delete(id);
+                    else
+                        this.activeRuns.set(id, runs);
+                    // A member whose round ended is no longer waiting on its cards: its
+                    // bridge call is gone (a CLI's own MCP timeout can end it early, and
+                    // the round then goes on without the answer). Expire them, so an
+                    // answer given now reaches the member as a new message.
+                    if (event.data.state !== 'running')
+                        this.expireCardsOf(id, event.data.member);
+                    if (before === 0 && runs.size > 0)
+                        this.emitStatus(id, true);
+                    // The room's own agent still running keeps the row running.
+                    else if (before > 0 && runs.size === 0 && this.ctx.agents.get(session.id)?.status !== 'running')
+                        this.emitStatus(id, false);
+                    return;
+                }
+                case 'room/question':
+                case 'room/approval': {
+                    const cards = this.waitingCards.get(id) ?? new Map();
+                    cards.set(event.data.id, { kind: event.type === 'room/question' ? 'question' : 'approval', member: event.data.member });
+                    this.waitingCards.set(id, cards);
+                    return;
+                }
+                case 'room/question-resolved':
+                case 'room/approval-resolved': {
+                    const cards = this.waitingCards.get(id);
+                    cards?.delete(event.data.id);
+                    if (cards?.size === 0)
+                        this.waitingCards.delete(id);
+                    return;
+                }
+                default:
+            }
+        }
+        /**
+         * End the waits behind one member's open cards (its round settled): the
+         * question/approval calls resolve as unanswered, which journals them
+         * expired — still answerable, by a new message (answerExpiredQuestion).
+         * @param roomId - the room session.
+         * @param member - the member whose round ended.
+         */
+        expireCardsOf(roomId, member) {
+            for (const [cardId, card] of this.waitingCards.get(roomId) ?? []) {
+                if (card.member !== member)
+                    continue;
+                if (card.kind === 'question')
+                    this.questionWaiters.get(cardId)?.(undefined);
+                else
+                    this.approvalWaiters.get(cardId)?.('cancelled');
+            }
+        }
+        /** Broadcast a room's running flip on the host's session-status channel. */
+        emitStatus(sessionId, running) {
+            this.ctx.emit('api-session/status', SessionId(sessionId), running);
+        }
+        /**
+         * The question/approval cards waiting for the human across live rooms —
+         * the browser publishes them as the session list's 等你处理 status.
+         * @param request - optionally one room only.
+         * @returns the waiting cards.
+         */
+        async pendingCards(request) {
+            const rooms = request.sessionId === undefined ? [...this.waitingCards.keys()] : [String(request.sessionId)];
+            return rooms.flatMap(sessionId => [...this.waitingCards.get(sessionId) ?? []].map(([id, card]) => ({ sessionId, id, kind: card.kind })));
+        }
         async isRoom(request) {
             const session = this.ctx.sessions.get(request.sessionId);
             if (session !== undefined)
@@ -800,14 +990,14 @@ let RoomService = (() => {
                 return { ok: false, code: 'unknown-targets' };
             const body = parsed.targets.length > 0 ? parsed.text : text;
             const filed = await this.fileHumanMessage(session, edit.data.id, text, task);
-            this.moveOnFromLostRounds(session, targets);
+            const carry = this.moveOnFromLostRounds(session, targets);
             const dispatch = session.append('room/dispatch', {
                 id: requestId, targets, text: body, origin: 'human', task: filed.task,
                 targetIds: targets.map(name => memberId(session.snapshotEvents(), current.members.find(member => member.name === name))),
             });
             await this.ctx.sessions.flush(session);
             for (const target of targets)
-                this.engine.dispatch(session, target, body, { dispatchSeq: dispatch.seq });
+                this.engine.dispatch(session, target, carry(target, body), { dispatchSeq: dispatch.seq });
             return { ok: true };
         }
         /**
@@ -816,10 +1006,12 @@ let RoomService = (() => {
          * message runs instead of queueing behind a reconciliation. Formal-goal
          * attempts keep their explicit reconciliation.
          */
-        moveOnFromLostRounds(session, targets, why = '你发了新消息；被重启打断的这一轮按没做完处理') {
+        moveOnFromLostRounds(session, targets, why = MOVED_ON_TEXT) {
             const events = session.snapshotEvents();
             const state = replay(events);
-            const ids = new Set(state.members.filter(member => targets.includes(member.name)).map(member => memberId(events, member)));
+            const members = state.members.filter(member => targets.includes(member.name));
+            const ids = new Set(members.map(member => memberId(events, member)));
+            const backlog = new Map();
             for (const row of state.deliveries ?? []) {
                 if (row.status !== 'uncertain' || row.plan?.taskId !== undefined || !ids.has(row.memberId))
                     continue;
@@ -827,7 +1019,24 @@ let RoomService = (() => {
                 const run = state.runs.find(entry => entry.runId === row.id);
                 if (run !== undefined)
                     session.append('room/run-state', { member: run.member, runId: row.id, startedAt: run.startedAt, state: 'cancelled', ...this.terminalRunStateFields(session, state, run.member) });
+                // The messages that queued behind the lost round never ran (the round
+                // blocked them, the restart lost the queue): they ride along with this
+                // message, one round, instead of replaying stale rounds one by one.
+                const name = members.find(member => memberId(events, member) === row.memberId)?.name;
+                if (name === undefined)
+                    continue;
+                for (const queued of state.deliveries ?? []) {
+                    if (queued.status !== 'queued' || queued.memberId !== row.memberId || queued.dispatchSeq <= row.dispatchSeq || queued.plan?.taskId !== undefined)
+                        continue;
+                    session.append('room/delivery-state', { id: queued.id, dispatchSeq: queued.dispatchSeq, memberId: queued.memberId, state: 'done', text: MERGED_BACKLOG_TEXT });
+                    const from = queued.from === undefined ? undefined : state.members.find(member => memberId(events, member) === queued.from)?.name;
+                    backlog.set(name, [...backlog.get(name) ?? [], `- ${from === undefined ? '' : `来自 ${from}：`}${queued.text}`]);
+                }
             }
+            return (member, text) => {
+                const lines = backlog.get(member);
+                return lines === undefined ? text : [text, '', '（你被重启打断期间，房间里还有这些消息排着没送到，一并给你：', ...lines, '）'].join('\n');
+            };
         }
         /**
          * Where a member's next send belongs: the task and delivery it is working
@@ -891,6 +1100,12 @@ let RoomService = (() => {
             const loaded = await this.loadCold(request.sessionId);
             if (!loaded.ok)
                 return { ok: false, error: loaded.error };
+            // A held report's wake timer lives in the process that held it: after a
+            // restart nothing would ever hand it over. A cold room holding one is
+            // brought live, whose recovery hands every untimed hold over.
+            if (this.ctx.sessions.get(request.sessionId) === undefined && (loaded.state.deliveries ?? []).some(row => row.status === 'held')) {
+                void this.ensureLive(request.sessionId).catch((error) => { this.ctx.logger.warn(`room: reviving held reports failed: ${String(error)}`); });
+            }
             return { ok: true, value: { ...this.engine.view(request.sessionId, loaded.state), ...loaded.state.plan === undefined ? {} : { plan: this.plans.view(request.sessionId, loaded.state.plan) } } };
         }
         /**
@@ -1358,9 +1573,13 @@ let RoomService = (() => {
             const loaded = await this.ensureLive(request.sessionId);
             if (!loaded.ok)
                 return { ok: false, error: loaded.error };
-            if (request.text.trim() === '')
+            const attached = request.attachments ?? [];
+            if (request.text.trim() === '' && attached.length === 0)
                 return { ok: false, error: { code: 'empty-text' } };
-            const requestSignature = createHash('sha256').update(JSON.stringify({ text: request.text.trim(), targets: [...new Set(request.targets ?? [])].sort() })).digest('hex');
+            const requestSignature = createHash('sha256').update(JSON.stringify({
+                text: request.text.trim(), targets: [...new Set(request.targets ?? [])].sort(),
+                ...attached.length === 0 ? {} : { attachments: attached.map(entry => entry.type === 'file' ? entry.receiptId : `${entry.mediaType}:${entry.data.length}`) },
+            })).digest('hex');
             if (request.requestId !== undefined) {
                 if (request.requestId.trim() === '' || request.requestId.length > 128)
                     return { ok: false, error: { code: 'request-conflict' } };
@@ -1378,7 +1597,7 @@ let RoomService = (() => {
                     for (const target of original.targetIds ?? []) {
                         const member = replay(loaded.session.snapshotEvents()).members.find(member => memberId(loaded.session.snapshotEvents(), member) === target);
                         if (member !== undefined)
-                            this.engine.dispatch(loaded.session, member.name, original.text, { dispatchSeq: previous.seq, targetId: target });
+                            this.engine.dispatch(loaded.session, member.name, withAttachmentPaths(original.text, original.attachments), { dispatchSeq: previous.seq, targetId: target });
                     }
                     return { ok: true, value: { parsed: { targets: original.targets, text: original.text }, seq: previous.seq } };
                 }
@@ -1401,9 +1620,10 @@ let RoomService = (() => {
             // The human pointing at a session outside the room is a help request: say
             // so every time (a member's briefing reaches it once, on its first round).
             const outside = [...said.matchAll(/@\[((?:\\.|[^\\\]\n])+)\]\((dsh-session:[^)\s]+)\)/gu)];
-            const text = said;
+            // An attachment-only message still dispatches: its words are the attachments.
+            const text = said === '' && attached.length > 0 ? '（见附件）' : said;
             // The hint rides the member's prompt only; the journal keeps the human's words.
-            const prompt = outside.length === 0 ? said : [
+            const prompt = outside.length === 0 ? text : [
                 said,
                 '',
                 `（人点名了房间外的会话：${outside.map(match => `「${match[1].replace(/\\(.)/gu, '$1')}」`).join('、')}。用 room_help 去问：session 参数原样传那个 @[…](dsh-session:…) 引用；标签是「成员（房间）」时会交给那个成员。不要转给别的成员代问。）`,
@@ -1414,23 +1634,103 @@ let RoomService = (() => {
             const unknown = targets.filter(target => !roster.has(target));
             if (unknown.length > 0)
                 return { ok: false, error: { code: 'unknown-targets', names: unknown } };
+            const admitted = await this.admitAttachments(request.sessionId, attached);
+            if (!admitted.ok)
+                return { ok: false, error: admitted.error };
             const human = createUserMessage({
-                content: [{ type: 'text', text: request.text.trim() }],
+                content: [...admitted.blocks, ...request.text.trim() === '' ? [] : [{ type: 'text', text: request.text.trim() }]],
                 source: { kind: 'user' },
             });
-            loaded.session.append('user/message', human, { surfaceOp: 'append' });
+            {
+                const env_1 = { stack: [], error: void 0, hasError: false };
+                try {
+                    // Uploaded files are bound to this message once it is in the log (an unbound receipt is reclaimed).
+                    const binding = __addDisposableResource(env_1, admitted.bind(request.requestId ?? String(human.id)), false);
+                    loaded.session.append('user/message', human, { surfaceOp: 'append' });
+                    binding?.commit();
+                }
+                catch (e_1) {
+                    env_1.error = e_1;
+                    env_1.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_1);
+                }
+            }
+            floatRunningCards(loaded.session);
             const filed = await this.fileHumanMessage(loaded.session, human.id, request.text.trim(), request.task ?? this.consumeTaskHint(request.sessionId));
-            this.moveOnFromLostRounds(loaded.session, targets);
+            const carry = this.moveOnFromLostRounds(loaded.session, targets);
             const dispatch = loaded.session.append('room/dispatch', {
                 id: request.requestId ?? randomUUID(), requestSignature, targets, text, origin: 'human', task: filed.task,
+                ...admitted.records.length === 0 ? {} : { attachments: admitted.records },
                 targetIds: targets.map(name => memberId(loaded.session.snapshotEvents(), loaded.state.members.find(member => member.name === name))),
             });
             await this.ctx.sessions.flush(loaded.session);
             for (const target of targets) {
-                this.engine.dispatch(loaded.session, target, prompt, { dispatchSeq: dispatch.seq });
+                this.engine.dispatch(loaded.session, target, carry(target, withAttachmentPaths(prompt, admitted.records)), { dispatchSeq: dispatch.seq });
             }
             return { ok: true, value: { parsed: { targets, text }, seq: dispatch.seq } };
         }
+        /**
+         * Admit a human message's composer attachments the way the host's own
+         * prompt path does: file receipts resolve against this room session's
+         * uploads, images are stored, and every attachment becomes a durable
+         * content block for the message — plus the local path members read it by.
+         * @param sessionId - the room session (its agent owns the uploads).
+         * @param inputs - the wire attachments.
+         * @returns the content blocks, the dispatch records, and the receipt binder; or a refusal.
+         */
+        async admitAttachments(sessionId, inputs) {
+            if (inputs.length === 0)
+                return { ok: true, blocks: [], records: [], bind: () => undefined };
+            const probe = this.ctx.get;
+            const services = {
+                attachments: probe('attachments'),
+                fileUploads: probe('fileUploads'),
+            };
+            const store = services.attachments;
+            // The uploads are staged on the room session's agent; a cold room wakes it.
+            let agent = this.ctx.agents.get(sessionId);
+            if (agent === undefined) {
+                const controller = this.ctx.get('sessionController');
+                const resolved = await controller?.resolveAgent?.(sessionId).catch(() => undefined);
+                if (resolved !== undefined && 'agent' in resolved)
+                    agent = resolved.agent;
+            }
+            if (store === undefined || agent === undefined)
+                return { ok: false, error: { code: 'attachment-invalid', message: 'attachments are unavailable on this host' } };
+            const receipts = [];
+            const parts = [];
+            for (const input of inputs) {
+                if (input.type === 'image') {
+                    parts.push({ type: 'image', data: input.data, mediaType: input.mediaType, ...input.name === undefined ? {} : { name: input.name } });
+                    continue;
+                }
+                const ref = services.fileUploads?.resolve(agent, input.receiptId);
+                if (ref === undefined)
+                    return { ok: false, error: { code: 'attachment-invalid', message: 'a file was not uploaded to this room' } };
+                receipts.push(input.receiptId);
+                parts.push({ type: 'file', attachment: ref });
+            }
+            let blocks;
+            try {
+                blocks = await store.admitPromptContent(parts);
+            }
+            catch (error) {
+                return { ok: false, error: { code: 'attachment-invalid', message: error instanceof Error ? error.message : String(error) } };
+            }
+            const records = blocks.flatMap((block) => {
+                if (block.type !== 'image' && block.type !== 'file')
+                    return [];
+                const path = block.type === 'image' ? store.imageHostPath?.(block.attachment) : store.fileHostPath?.(block.attachment);
+                return [{ kind: block.type, ...block.attachment?.name === undefined ? {} : { name: block.attachment.name }, ...path === undefined ? {} : { path } }];
+            });
+            const uploads = services.fileUploads;
+            return {
+                ok: true, blocks, records,
+                bind: requestId => receipts.length === 0 || uploads === undefined ? undefined : uploads.bindPrompt(agent, receipts, requestId),
+            };
+        }
         /**
          * Send one message from a member to another (host-only — the `room_message`
          * tool and the bridge's `member_message`/`room_message` land here; the
@@ -1634,7 +1934,7 @@ let RoomService = (() => {
                         id: 'help', header: '求助',
                         question: `${asker.name} 想向会话「${target.title}」求助：${text.length > 80 ? `${text.slice(0, 80)}…` : text}`,
                         options: [{ label: '允许' }, { label: '不允许' }],
-                    }], 10 * 60_000);
+                    }], 10 * 60_000, true);
                 if (answers?.[0]?.selected[0] !== '允许')
                     return `The human did not allow asking "${target.title}". Do not retry unless they @ that session in the room.`;
             }
@@ -1673,7 +1973,7 @@ let RoomService = (() => {
             // A round a restart left uncertain blocks the member's later work until a
             // human reconciles it — silently, for a request from outside. Move on
             // from it, as a human message to that member does.
-            this.moveOnFromLostRounds(other.session, [member.name], '另一个协作间来求助；被重启打断的这一轮按没做完处理');
+            const carry = this.moveOnFromLostRounds(other.session, [member.name], '另一个协作间来求助；被重启打断的这一轮按没做完处理');
             const sent = sendOrHold(other.session, {
                 to: member, text, fromName: `${help.fromName}（${origin.roomTitle}）`,
                 intent: { origin: 'help', hop: 1, kind: 'task', help: origin, ...op === 'request' ? { task: SELF_TASK } : {} },
@@ -1683,7 +1983,7 @@ let RoomService = (() => {
             room.append('room/help-state', { help: help.id, state: sent.delivered ? 'running' : 'queued' });
             await this.ctx.sessions.flush(room);
             if (sent.delivered)
-                this.engine.dispatch(other.session, member.name, text, { dispatchSeq: sent.seq });
+                this.engine.dispatch(other.session, member.name, carry(member.name, text), { dispatchSeq: sent.seq });
             const who = `${member.name} in the room "${help.target.title}"`;
             return `${sent.delivered ? `Sent to ${who}.` : `Sent to ${who}; that room is paused, so the request waits until it resumes.`}`
                 + ` Help id: ${help.id}. The reply reaches you on its own — end your turn now; do not poll.`;
@@ -2003,13 +2303,23 @@ let RoomService = (() => {
          * @param timeoutMs - how long the call waits before it gives up.
          * @returns the answers, or undefined when nobody answered.
          */
-        async askQuestions(session, member, questions, timeoutMs) {
+        async askQuestions(session, member, questions, timeoutMs, consent = false) {
             const id = randomUUID();
             const answered = new Promise((resolve) => {
                 this.questionWaiters.set(id, resolve);
                 setTimeout(() => { resolve(undefined); }, timeoutMs).unref?.();
             });
-            session.append('room/question', { id, member: member.name, memberId: memberId(session.snapshotEvents(), member), questions });
+            // Place the question inside the asker's round: its run, and the tail of
+            // what the round had said so far (the reply splits there when it lands).
+            const run = replay(session.snapshotEvents()).runs.find(entry => entry.member === member.name && entry.state === 'running');
+            const child = member.childSessionId === undefined ? undefined : this.ctx.sessions.get(member.childSessionId);
+            const before = child === undefined ? '' : roundTextSoFar(child.snapshotEvents()).slice(-BEFORE_TAIL);
+            session.append('room/question', {
+                id, member: member.name, memberId: memberId(session.snapshotEvents(), member), questions,
+                ...consent ? { consent: true } : {},
+                ...run?.runId === undefined ? {} : { runId: run.runId },
+                ...before.trim() === '' ? {} : { before },
+            });
             await this.ctx.sessions.flush(session);
             const answers = await answered;
             this.questionWaiters.delete(id);
@@ -2031,7 +2341,7 @@ let RoomService = (() => {
             const waiter = this.questionWaiters.get(request.id);
             const pending = loaded.state.questions?.find(entry => entry.id === request.id);
             if (waiter === undefined || pending === undefined)
-                return { ok: false, error: { code: 'question-not-pending' } };
+                return this.answerExpiredQuestion(loaded.session, request);
             // Keep only answers to this card's own questions, in the shape the asker expects.
             const answers = pending.questions.map((question) => {
                 const given = request.answers.find(answer => answer.id === question.id);
@@ -2043,6 +2353,44 @@ let RoomService = (() => {
             waiter(answers);
             return { ok: true };
         }
+        /**
+         * Answer a card whose waiting call is gone (it timed out, or a restart
+         * ended the member's process): the card records the answers, and they
+         * reach the member as a new message that wakes it with its own context —
+         * the member asked so it could go on, so a late answer is still worth it.
+         * A consent gate is never answered late: its call already decided.
+         * @param session - the live room session.
+         * @param request - card id and the human's answers.
+         * @returns ok, or `question-not-pending` when the card is not an expired, unanswered question.
+         */
+        async answerExpiredQuestion(session, request) {
+            const events = session.snapshotEvents();
+            const asked = events.find(event => event.type === 'room/question' && event.data.id === request.id);
+            if (asked?.type !== 'room/question' || asked.data.consent === true)
+                return { ok: false, error: { code: 'question-not-pending' } };
+            const outcomes = events.filter(event => event.type === 'room/question-resolved' && event.data.id === request.id);
+            // Expired, or still open with no call behind it (a restart this room has not swept yet).
+            const last = outcomes.at(-1);
+            if (last !== undefined && (last.type !== 'room/question-resolved' || last.data.outcome !== 'cancelled'))
+                return { ok: false, error: { code: 'question-not-pending' } };
+            const member = replay(events).members.find(entry => memberId(events, entry) === asked.data.memberId);
+            if (member === undefined)
+                return { ok: false, error: { code: 'question-not-pending' } };
+            const answers = asked.data.questions.map((question) => {
+                const given = request.answers.find(answer => answer.id === question.id);
+                const custom = given?.custom?.trim();
+                return { id: question.id, selected: [...given?.selected ?? []].filter(label => typeof label === 'string'), ...custom === undefined || custom === '' ? {} : { custom } };
+            });
+            session.append('room/question-resolved', { id: request.id, outcome: 'answered', answers, late: true });
+            const text = lateAnswerText(asked.data.questions, answers);
+            const carry = this.moveOnFromLostRounds(session, [member.name]);
+            const dispatch = session.append('room/dispatch', {
+                id: randomUUID(), targets: [member.name], targetIds: [memberId(events, member)], text, origin: 'human',
+            });
+            await this.ctx.sessions.flush(session);
+            this.engine.dispatch(session, member.name, carry(member.name, text), { dispatchSeq: dispatch.seq });
+            return { ok: true };
+        }
         /** Shared backend for external MCP room tools. Not exposed as a browser Remote. */
         async receiveMemberCommand(actor, command) {
             try {

package/lib/types/jobs.js

@@ -22,8 +22,12 @@ export function replayJobs(events, deliveries) {
         }
         else if (event.type === 'room/job-stopped')
             stopped.add(event.data.task);
-        else if (event.type === 'room/dispatch' && event.data.id !== undefined)
-            dispatchById.set(event.data.id, { time: event.time, text: event.data.text });
+        else if (event.type === 'room/dispatch' && event.data.id !== undefined) {
+            // A task rooted in a member's dispatch (the coordinator delegating) is
+            // that member's words, not the human's.
+            const from = event.data.origin !== 'human' && event.data.from !== undefined ? event.data.from : undefined;
+            dispatchById.set(event.data.id, { time: event.time, text: event.data.text, ...from === undefined ? {} : { from } });
+        }
     }
     const byTask = new Map();
     for (const row of deliveries) {
@@ -55,7 +59,7 @@ export function replayJobs(events, deliveries) {
             id, number: index + 1,
             // Leading @-mentions address members; the request is what follows.
             title: (root.text.replace(/^(?:@\S+\s+)+/, '').split('\n', 1)[0] ?? '').slice(0, 120),
-            messages: [{ id, time: root.time, text: root.text }, ...follow].sort((a, b) => a.time - b.time),
+            messages: [{ id, time: root.time, text: root.text, ...root.from === undefined ? {} : { from: root.from } }, ...follow].sort((a, b) => a.time - b.time),
             status, startedAt: root.time,
             ...open ? {} : { endedAt: ended },
             deliveries: rows.map(row => row.id),

package/lib/types/journal.d.ts

@@ -20,7 +20,7 @@ export declare const ROOM_ROLE_MAX = 30;
  * in-place add is that surface's temporary form — migrate to the official
  * one when it lands upstream.
  */
-export declare const ROOM_EVENT_TYPES: readonly ['room/created', 'room/plan-state', 'room/coordinator', 'room/delivery-state', 'room/member-added', 'room/member-updated', 'room/member-removed', 'room/dispatch', 'room/speech', 'room/run-state', 'room/execution-metadata', 'room/relay', 'room/relay-resolved', 'room/approval', 'room/approval-resolved', 'room/question', 'room/question-resolved', 'room/task-added', 'room/task-updated', 'room/task-edited', 'room/goal', 'room/settings', 'room/report-gate', 'room/decision', 'room/task-link', 'room/job-stopped', 'room/help', 'room/help-message', 'room/help-state', 'room/help-in', 'room/help-link', 'room/help-unlink', 'room/help-nudge-dismissed'];
+export declare const ROOM_EVENT_TYPES: readonly ['room/created', 'room/plan-state', 'room/coordinator', 'room/delivery-state', 'room/member-added', 'room/member-updated', 'room/member-removed', 'room/dispatch', 'room/speech', 'room/run-state', 'room/run-moved', 'room/execution-metadata', 'room/relay', 'room/relay-resolved', 'room/approval', 'room/approval-resolved', 'room/question', 'room/question-resolved', 'room/task-added', 'room/task-updated', 'room/task-edited', 'room/goal', 'room/settings', 'room/report-gate', 'room/decision', 'room/task-link', 'room/job-stopped', 'room/help', 'room/help-message', 'room/help-state', 'room/help-in', 'room/help-link', 'room/help-unlink', 'room/help-nudge-dismissed'];
 /** Collaboration settings of a room that never changed them. */
 export declare const DEFAULT_ROOM_SETTINGS: RoomSettings;
 /** Whether an event log carries the room identity marker. */