@khorsheed/dsh-room 0.2.3 → 0.2.5

package/lib/index.js

@@ -700,10 +700,14 @@ function replayJobs(events, deliveries) {
 		...event.data.probability === void 0 ? {} : { probability: event.data.probability }
 	});
 	else if (event.type === "room/job-stopped") stopped.add(event.data.task);
-	else if (event.type === "room/dispatch" && event.data.id !== void 0) dispatchById.set(event.data.id, {
-		time: event.time,
-		text: event.data.text
-	});
+	else if (event.type === "room/dispatch" && event.data.id !== void 0) {
+		const from = event.data.origin !== "human" && event.data.from !== void 0 ? event.data.from : void 0;
+		dispatchById.set(event.data.id, {
+			time: event.time,
+			text: event.data.text,
+			...from === void 0 ? {} : { from }
+		});
+	}
 	const byTask = /* @__PURE__ */ new Map();
 	for (const row of deliveries) {
 		if (row.task === void 0) continue;
@@ -735,7 +739,8 @@ function replayJobs(events, deliveries) {
 			messages: [{
 				id,
 				time: root.time,
-				text: root.text
+				text: root.text,
+				...root.from === void 0 ? {} : { from: root.from }
 			}, ...follow].sort((a, b) => a.time - b.time),
 			status,
 			startedAt: root.time,
@@ -856,6 +861,7 @@ const ROOM_EVENT_TYPES = [
 	"room/dispatch",
 	"room/speech",
 	"room/run-state",
+	"room/run-moved",
 	"room/execution-metadata",
 	"room/relay",
 	"room/relay-resolved",
@@ -937,6 +943,7 @@ function replay(events) {
 	const relays = [];
 	const approvals = /* @__PURE__ */ new Map();
 	const questions = /* @__PURE__ */ new Map();
+	const asks = /* @__PURE__ */ new Map();
 	const relayById = /* @__PURE__ */ new Map();
 	const tasks = [];
 	const taskById = /* @__PURE__ */ new Map();
@@ -1090,10 +1097,27 @@ function replay(events) {
 				questions: event.data.questions,
 				time: event.time
 			});
+			asks.set(event.data.id, {
+				id: event.data.id,
+				member: event.data.member,
+				questions: event.data.questions,
+				state: "pending",
+				time: event.time,
+				...event.data.runId === void 0 ? {} : { runId: event.data.runId },
+				...event.data.consent === true ? { consent: true } : {}
+			});
 			break;
-		case "room/question-resolved":
+		case "room/question-resolved": {
 			questions.delete(event.data.id);
+			const ask = asks.get(event.data.id);
+			if (ask !== void 0) asks.set(ask.id, {
+				...ask,
+				state: event.data.outcome,
+				...event.data.answers === void 0 ? {} : { answers: event.data.answers },
+				...event.data.late === true ? { late: true } : {}
+			});
 			break;
+		}
 		case "room/approval-resolved":
 			approvals.delete(event.data.id);
 			break;
@@ -1216,6 +1240,7 @@ function replay(events) {
 		relays,
 		...approvals.size === 0 ? {} : { approvals: [...approvals.values()] },
 		...questions.size === 0 ? {} : { questions: [...questions.values()] },
+		...asks.size === 0 ? {} : { askLog: [...asks.values()] },
 		tasks,
 		...executions.size === 0 ? {} : { executions: [...executions.values()] },
 		...plan === void 0 ? {} : { plan },
@@ -1948,11 +1973,89 @@ function roomSource() {
 	return Object.freeze({ kind: ROOM_KIND });
 }
 /**
-* A run-state edge's child-session identity: the main agent runs on the room
-* itself, external members on their child session. Optional — a fresh CLI
-* member's early running edge predates the child handle's publication (the
-* terminal edge and the journal backfill cover it).
+* The text a member's current round has said so far in its own session: the
+* assistant text blocks since the latest turn start, in order.
+* @param events - the member's child session log.
+* @returns the round's text so far.
 */
+function roundTextSoFar(events) {
+	let start = -1;
+	for (let index = events.length - 1; index >= 0; index -= 1) if (events[index].type === "turn/start") {
+		start = index;
+		break;
+	}
+	const parts = [];
+	for (const event of events.slice(start + 1)) {
+		if (event.type !== "assistant/message") continue;
+		const content = event.data.message?.content ?? [];
+		for (const block of content) if (block.type === "text" && typeof block.text === "string") parts.push(block.text);
+	}
+	return parts.join("");
+}
+/**
+* Where each question a round asked sits in its final reply: just after the
+* text the round had said when it asked (its recorded tail, shortened until
+* found). Asked before saying anything → 0; tail not found → -1 (shown
+* first, marked as asked mid-round). Offsets never go backwards.
+* @param events - the room log.
+* @param runId - the round.
+* @param text - the round's reply.
+* @returns the question ids with their offsets.
+*/
+function askOffsets(events, runId, text) {
+	const out = [];
+	let floor = 0;
+	for (const event of events) {
+		if (event.type !== "room/question" || event.data.runId !== runId) continue;
+		const tail = (event.data.before ?? "").trimEnd();
+		let at = tail === "" ? 0 : -1;
+		for (const size of [
+			80,
+			40,
+			20
+		]) {
+			if (tail === "") break;
+			const probe = tail.slice(-size);
+			if (probe.length < Math.min(size, 8)) break;
+			const found = text.indexOf(probe, floor);
+			if (found >= 0) {
+				at = found + probe.length;
+				break;
+			}
+		}
+		if (at > 0) floor = at;
+		out.push({
+			id: event.data.id,
+			at
+		});
+	}
+	return out;
+}
+/** Why a human message's move-on closes a restart-lost round (index.ts moveOnFromLostRounds). */
+const MOVED_ON_TEXT = "你发了新消息；被重启打断的这一轮按没做完处理";
+/** A message that queued behind a lost round and rode along with the move-on message. */
+const MERGED_BACKLOG_TEXT = "已并入下一条消息一起送达";
+/** A message that queued behind a lost round an earlier move-on skipped: closed, not replayed. */
+const SUPERSEDED_BACKLOG_TEXT = "被重启打断前排队，已被后续消息取代";
+/**
+* Whether a queued delivery sat behind a restart-lost round of the same
+* member that a human message has since moved on from (its dispatch lies
+* between the lost round and the move-on edge).
+* @param events - the room journal.
+* @param targetId - the member id.
+* @param dispatchSeq - the queued delivery's dispatch seq.
+* @returns whether the move-on superseded it.
+*/
+function supersededByMoveOn(events, targetId, dispatchSeq) {
+	return events.some((event) => event.type === "room/delivery-state" && event.data.memberId === targetId && event.data.state === "cancelled" && event.data.text === "你发了新消息；被重启打断的这一轮按没做完处理" && event.data.dispatchSeq < dispatchSeq && dispatchSeq < event.seq);
+}
+function floatRunningCards(room, except) {
+	const running = replay(room.snapshotEvents()).runs.filter((run) => run.state === "running" && run.member !== except).sort((left, right) => left.startedAt - right.startedAt);
+	for (const run of running) room.append("room/run-moved", {
+		member: run.member,
+		startedAt: run.startedAt
+	});
+}
 function runChildSessionId(roomId, member) {
 	if (member?.kind === "main-agent") return roomId;
 	return member?.childSessionId;
@@ -2272,6 +2375,17 @@ var DispatchEngine = class {
 					} else await this.reportOutcome(room, dispatch.seq, id, targetId, last.data.state, last.data.text ?? last.data.error ?? "");
 					continue;
 				}
+				if (supersededByMoveOn(events, targetId, dispatch.seq)) {
+					room.append("room/delivery-state", {
+						id,
+						dispatchSeq: dispatch.seq,
+						memberId: targetId,
+						state: "cancelled",
+						text: SUPERSEDED_BACKLOG_TEXT
+					});
+					await this.ctx.sessions.flush(room);
+					continue;
+				}
 				const target = state.members.find((member) => memberId(events, member) === targetId);
 				if (target !== void 0 && !state.deliveries?.some((row) => row.memberId === targetId && (row.status === "running" || row.status === "uncertain"))) this.dispatch(room, target.name, dispatch.data.text, {
 					dispatchSeq: dispatch.seq,
@@ -2351,7 +2465,28 @@ var DispatchEngine = class {
 	* coordinator for plan work, else the dispatch's `replyTo`), at most once
 	* per delivery. Public so a removal can settle the waits it breaks.
 	*/
+	/** Report-gate decisions per recipient, one at a time (see reportOutcome). */
+	gateQueues = /* @__PURE__ */ new Map();
+	/**
+	* Gate one arrived report for the member waiting on it. Decisions for the
+	* same recipient run one at a time: a decision-model judgement takes a
+	* second or two, and a later report deciding meanwhile (the 「最后一个结果」
+	* rule) would hand over its batch without the one still being judged —
+	* which then got held behind a round that had already answered.
+	*/
 	async reportOutcome(room, dispatchSeq, deliveryId, fromId, outcome, text) {
+		const source = room.snapshotEvents().find((event) => event.seq === dispatchSeq);
+		const key = `${room.id} ${source?.type === "room/dispatch" ? source.data.replyTo ?? "" : ""}`;
+		const next = (this.gateQueues.get(key) ?? Promise.resolve()).catch(() => {}).then(() => this.gateReport(room, dispatchSeq, deliveryId, fromId, outcome, text));
+		this.gateQueues.set(key, next);
+		next.then(() => {
+			if (this.gateQueues.get(key) === next) this.gateQueues.delete(key);
+		}, () => {
+			if (this.gateQueues.get(key) === next) this.gateQueues.delete(key);
+		});
+		return next;
+	}
+	async gateReport(room, dispatchSeq, deliveryId, fromId, outcome, text) {
 		const events = room.snapshotEvents();
 		const source = events.find((event) => event.seq === dispatchSeq);
 		if (source?.type !== "room/dispatch" || source.data.origin !== "coordinator" && source.data.origin !== "member" || source.data.replyTo === void 0) return;
@@ -2649,6 +2784,7 @@ var DispatchEngine = class {
 			...lastAssistantMessageId(agent.session, before) === void 0 ? {} : { messageId: lastAssistantMessageId(agent.session, before) },
 			...reportedTo === void 0 ? {} : { reportedTo }
 		});
+		floatRunningCards(room, replay(room.snapshotEvents()).members.find((entry) => entry.id === member.id)?.name ?? member.name);
 		await this.ctx.sessions.flush(room);
 		return {
 			state: "done",
@@ -2750,16 +2886,22 @@ var DispatchEngine = class {
 		const interrupted = result.stopReason === "completed" ? void 0 : result.stopReason === "aborted" ? "cancelled" : "failed";
 		const reportedTo = dispatchSeq === void 0 ? void 0 : reportRecipient(room.snapshotEvents(), dispatchSeq)?.name;
 		const closingMessageId = lastAssistantMessageId(this.ctx.sessions.get(run.id));
-		if ((output !== "" || interrupted === void 0 ? room.append("room/speech", {
+		const asks = askOffsets(room.snapshotEvents(), runId, output);
+		const speech = output !== "" || interrupted === void 0 ? room.append("room/speech", {
 			member: replay(room.snapshotEvents()).members.find((entry) => entry.id === member.id)?.name ?? member.name,
 			text: output,
+			...asks.length === 0 ? {} : { asks },
 			childSessionId: run.id,
 			runId,
 			...closingMessageId === void 0 ? {} : { messageId: closingMessageId },
 			durationMs: Date.now() - startedAt,
 			...interrupted === void 0 ? {} : { interrupted },
 			...reportedTo === void 0 ? {} : { reportedTo }
-		}) : void 0) !== void 0) await this.ctx.sessions.flush(room);
+		}) : void 0;
+		if (speech !== void 0) {
+			floatRunningCards(room, speech.data.member);
+			await this.ctx.sessions.flush(room);
+		}
 		if (result.stopReason === "completed") {
 			await this.ctx.sessions.flush(room);
 			return {
@@ -3426,6 +3568,64 @@ var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializ
 	if (target) Object.defineProperty(target, contextIn.name, descriptor);
 	done = true;
 };
+var __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,
+			dispose,
+			async
+		});
+	} else if (async) env.stack.push({ async: true });
+	return value;
+};
+var __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 = function(path, preserveJsx) {
 	if (typeof path === "string" && /^\.\.?\//.test(path)) return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
 		return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
@@ -3497,6 +3697,44 @@ function parseQuestions(raw) {
 	if (new Set(questions.map((question) => question.id)).size !== questions.length) 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.
+*/
+function lateAnswerText(questions, answers) {
+	return [
+		"你之前用 ask_user_question 问的问题没等到回答就过期了，人现在补答了：",
+		...questions.map((question) => {
+			const answer = answers.find((entry) => entry.id === question.id);
+			const picked = [...answer?.selected ?? [], ...answer?.custom === void 0 ? [] : [answer.custom]].join("；");
+			return `- ${question.header === void 0 ? "" : `${question.header}：`}${question.question} → ${picked === "" ? "（没选）" : picked}`;
+		}),
+		"",
+		"按这些答案继续。如果你已经按自己的假设往下做了，对照答案调整，并说一下改了什么。"
+	].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.
+*/
+function withAttachmentPaths(text, attachments) {
+	if (attachments === void 0 || attachments.length === 0) return text;
+	return [
+		text,
+		"",
+		"人随消息附了这些附件，用你自己的读取工具打开（图片用能看图的读取工具）：",
+		...attachments.map((entry) => {
+			return `- ${`${entry.kind === "image" ? "图片" : "文件"}${entry.name === void 0 ? "" : ` ${entry.name}`}`}：${entry.path ?? "（宿主没有给出本地路径，打不开就告诉人）"}`;
+		})
+	].join("\n");
+}
 function messageReceipt(receipt, kind) {
 	if (receipt.held !== void 0) return `pending-confirm （${receipt.held === "paused" ? "房间已暂停，恢复后自动投递" : receipt.held === "hop-limit" ? "这条消息链已到跳数上限，等房间主人决定是否继续" : "房间设置为成员间消息需房间主人确认"}）`;
 	return kind === "notify" ? `sent #${receipt.messageId}（知会，不会回报）` : `sent #${receipt.messageId}（${receipt.member} 做完后结果会自动回报给你；不要 sleep 等待，也不要用 room_read 轮询）`;
@@ -3540,6 +3778,7 @@ 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;
@@ -3569,6 +3808,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")];
@@ -3595,6 +3835,17 @@ 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",
@@ -4014,6 +4265,12 @@ let RoomService = (() => {
 					messages: []
 				};
 			});
+			ctx.on("session/event", (session, event) => {
+				this.observeActivity(session, event);
+			});
+			ctx.on("agent/status", ({ agent, status }) => {
+				if (status !== "running" && (this.activeRuns.get(String(agent.id))?.size ?? 0) > 0) this.emitStatus(String(agent.id), true);
+			});
 			const scanned = /* @__PURE__ */ new WeakSet();
 			ctx.on("agent/pre-step", async ({ agent, step }, next) => {
 				const decision = await next();
@@ -4141,6 +4398,84 @@ 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 = /* @__PURE__ */ new Map();
+		/** Question/approval cards waiting for the human, per room. */
+		waitingCards = /* @__PURE__ */ 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) ?? /* @__PURE__ */ 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);
+					if (event.data.state !== "running") this.expireCardsOf(id, event.data.member);
+					if (before === 0 && runs.size > 0) this.emitStatus(id, true);
+					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) ?? /* @__PURE__ */ 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;
+				}
+			}
+		}
+		/**
+		* 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)?.(void 0);
+				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) {
+			return (request.sessionId === void 0 ? [...this.waitingCards.keys()] : [String(request.sessionId)]).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 !== void 0) return isRoomLog(session.snapshotEvents());
@@ -4463,7 +4798,7 @@ let RoomService = (() => {
 			};
 			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,
@@ -4473,7 +4808,7 @@ let RoomService = (() => {
 				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 });
+			for (const target of targets) this.engine.dispatch(session, target, carry(target, body), { dispatchSeq: dispatch.seq });
 			return { ok: true };
 		}
 		/**
@@ -4482,10 +4817,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 = /* @__PURE__ */ new Map();
 			for (const row of state.deliveries ?? []) {
 				if (row.status !== "uncertain" || row.plan?.taskId !== void 0 || !ids.has(row.memberId)) continue;
 				session.append("room/delivery-state", {
@@ -4503,7 +4840,31 @@ let RoomService = (() => {
 					state: "cancelled",
 					...this.terminalRunStateFields(session, state, run.member)
 				});
+				const name = members.find((member) => memberId(events, member) === row.memberId)?.name;
+				if (name === void 0) continue;
+				for (const queued of state.deliveries ?? []) {
+					if (queued.status !== "queued" || queued.memberId !== row.memberId || queued.dispatchSeq <= row.dispatchSeq || queued.plan?.taskId !== void 0) 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 === void 0 ? void 0 : state.members.find((member) => memberId(events, member) === queued.from)?.name;
+					backlog.set(name, [...backlog.get(name) ?? [], `- ${from === void 0 ? "" : `来自 ${from}：`}${queued.text}`]);
+				}
 			}
+			return (member, text) => {
+				const lines = backlog.get(member);
+				return lines === void 0 ? text : [
+					text,
+					"",
+					"（你被重启打断期间，房间里还有这些消息排着没送到，一并给你：",
+					...lines,
+					"）"
+				].join("\n");
+			};
 		}
 		/**
 		* Where a member's next send belongs: the task and delivery it is working
@@ -4576,6 +4937,9 @@ let RoomService = (() => {
 				ok: false,
 				error: loaded.error
 			};
+			if (this.ctx.sessions.get(request.sessionId) === void 0 && (loaded.state.deliveries ?? []).some((row) => row.status === "held")) this.ensureLive(request.sessionId).catch((error) => {
+				this.ctx.logger.warn(`room: reviving held reports failed: ${String(error)}`);
+			});
 			return {
 				ok: true,
 				value: {
@@ -5226,13 +5590,15 @@ let RoomService = (() => {
 				ok: false,
 				error: loaded.error
 			};
-			if (request.text.trim() === "") return {
+			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()
+				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 !== void 0) {
 				if (request.requestId.trim() === "" || request.requestId.length > 128) return {
@@ -5252,7 +5618,7 @@ let RoomService = (() => {
 					await this.ctx.sessions.flush(loaded.session);
 					for (const target of original.targetIds ?? []) {
 						const member = replay(loaded.session.snapshotEvents()).members.find((member) => memberId(loaded.session.snapshotEvents(), member) === target);
-						if (member !== void 0) this.engine.dispatch(loaded.session, member.name, original.text, {
+						if (member !== void 0) this.engine.dispatch(loaded.session, member.name, withAttachmentPaths(original.text, original.attachments), {
 							dispatchSeq: previous.seq,
 							targetId: target
 						});
@@ -5285,8 +5651,8 @@ let RoomService = (() => {
 			}
 			const said = parsed.targets.length > 0 ? parsed.text : request.text.trim();
 			const outside = [...said.matchAll(/@\[((?:\\.|[^\\\]\n])+)\]\((dsh-session:[^)\s]+)\)/gu)];
-			const text = said;
-			const prompt = outside.length === 0 ? said : [
+			const text = said === "" && attached.length > 0 ? "（见附件）" : said;
+			const prompt = outside.length === 0 ? text : [
 				said,
 				"",
 				`（人点名了房间外的会话：${outside.map((match) => `「${match[1].replace(/\\(.)/gu, "$1")}」`).join("、")}。用 room_help 去问：session 参数原样传那个 @[…](dsh-session:…) 引用；标签是「成员（房间）」时会交给那个成员。不要转给别的成员代问。）`
@@ -5304,16 +5670,38 @@ let RoomService = (() => {
 					names: unknown
 				}
 			};
+			const admitted = await this.admitAttachments(request.sessionId, attached);
+			if (!admitted.ok) return {
+				ok: false,
+				error: admitted.error
+			};
 			const human = createUserMessage({
-				content: [{
+				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 {
+					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,
@@ -5321,10 +5709,11 @@ let RoomService = (() => {
 				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 });
+			for (const target of targets) this.engine.dispatch(loaded.session, target, carry(target, withAttachmentPaths(prompt, admitted.records)), { dispatchSeq: dispatch.seq });
 			return {
 				ok: true,
 				value: {
@@ -5337,6 +5726,95 @@ let RoomService = (() => {
 			};
 		}
 		/**
+		* 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: () => void 0
+			};
+			const probe = this.ctx.get;
+			const services = {
+				attachments: probe("attachments"),
+				fileUploads: probe("fileUploads")
+			};
+			const store = services.attachments;
+			let agent = this.ctx.agents.get(sessionId);
+			if (agent === void 0) {
+				const resolved = await this.ctx.get("sessionController")?.resolveAgent?.(sessionId).catch(() => void 0);
+				if (resolved !== void 0 && "agent" in resolved) agent = resolved.agent;
+			}
+			if (store === void 0 || agent === void 0) 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 === void 0 ? {} : { name: input.name }
+					});
+					continue;
+				}
+				const ref = services.fileUploads?.resolve(agent, input.receiptId);
+				if (ref === void 0) 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 === void 0 ? {} : { name: block.attachment.name },
+					...path === void 0 ? {} : { path }
+				}];
+			});
+			const uploads = services.fileUploads;
+			return {
+				ok: true,
+				blocks,
+				records,
+				bind: (requestId) => receipts.length === 0 || uploads === void 0 ? void 0 : 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
 		* human's path is postMessage). Any member may message any other: the
@@ -5538,7 +6016,7 @@ let RoomService = (() => {
 					header: "求助",
 					question: `${asker.name} 想向会话「${target.title}」求助：${text.length > 80 ? `${text.slice(0, 80)}…` : text}`,
 					options: [{ label: "允许" }, { label: "不允许" }]
-				}], 6e5))?.[0]?.selected[0] !== "允许") return `The human did not allow asking "${target.title}". Do not retry unless they @ that session in the room.`;
+				}], 6e5, true))?.[0]?.selected[0] !== "允许") return `The human did not allow asking "${target.title}". Do not retry unless they @ that session in the room.`;
 			}
 			const help = {
 				id: randomUUID().slice(0, 8),
@@ -5583,7 +6061,7 @@ let RoomService = (() => {
 				roomTitle: this.roomTitle(room),
 				from: help.fromName
 			};
-			this.moveOnFromLostRounds(other.session, [member.name], "另一个协作间来求助；被重启打断的这一轮按没做完处理");
+			const carry = this.moveOnFromLostRounds(other.session, [member.name], "另一个协作间来求助；被重启打断的这一轮按没做完处理");
 			const sent = sendOrHold(other.session, {
 				to: member,
 				text,
@@ -5609,7 +6087,7 @@ let RoomService = (() => {
 				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 });
+			if (sent.delivered) 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.`;
 		}
@@ -5993,7 +6471,7 @@ 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);
@@ -6001,11 +6479,17 @@ let RoomService = (() => {
 					resolve(void 0);
 				}, timeoutMs).unref?.();
 			});
+			const run = replay(session.snapshotEvents()).runs.find((entry) => entry.member === member.name && entry.state === "running");
+			const child = member.childSessionId === void 0 ? void 0 : this.ctx.sessions.get(member.childSessionId);
+			const before = child === void 0 ? "" : roundTextSoFar(child.snapshotEvents()).slice(-160);
 			session.append("room/question", {
 				id,
 				member: member.name,
 				memberId: memberId(session.snapshotEvents(), member),
-				questions
+				questions,
+				...consent ? { consent: true } : {},
+				...run?.runId === void 0 ? {} : { runId: run.runId },
+				...before.trim() === "" ? {} : { before }
 			});
 			await this.ctx.sessions.flush(session);
 			const answers = await answered;
@@ -6032,10 +6516,7 @@ let RoomService = (() => {
 			};
 			const waiter = this.questionWaiters.get(request.id);
 			const pending = loaded.state.questions?.find((entry) => entry.id === request.id);
-			if (waiter === void 0 || pending === void 0) return {
-				ok: false,
-				error: { code: "question-not-pending" }
-			};
+			if (waiter === void 0 || pending === void 0) return this.answerExpiredQuestion(loaded.session, request);
 			const answers = pending.questions.map((question) => {
 				const given = request.answers.find((answer) => answer.id === question.id);
 				const custom = given?.custom?.trim();
@@ -6054,6 +6535,61 @@ 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 last = events.filter((event) => event.type === "room/question-resolved" && event.data.id === request.id).at(-1);
+			if (last !== void 0 && (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 === void 0) 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 === void 0 || 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 {
@@ -6619,4 +7155,4 @@ let RoomService = (() => {
 	};
 })();
 //#endregion
-export { MAIN_AGENT_MEMBER, ROOM_EVENT_TYPES, RoomService, RoomService as default, handoffText, parseQuestions };
+export { MAIN_AGENT_MEMBER, ROOM_EVENT_TYPES, RoomService, RoomService as default, handoffText, lateAnswerText, parseQuestions, withAttachmentPaths };