@khorsheed/dsh-room 0.2.3 → 0.2.5

package/lib/types/client/nodes.d.ts

@@ -11,7 +11,7 @@
  * RoomService.postMessage) and renders through the official user node.
  * @module @khorsheed/dsh-room/client/nodes
  */
-import type { RoomDecisionEvent, RoomHelp, RoomQuestionAnswer, RoomQuestionItem } from '../types.ts';
+import type { RoomAsk, RoomDecisionEvent, RoomHelp, RoomQuestionAnswer, RoomQuestionItem } from '../types.ts';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { ConversationNodeDefinition } from '@deepseek-ai/dsh-client-ui-conversation/client';
 /** Chat node data of one member speech row. */
@@ -26,6 +26,11 @@ export interface RoomSpeechData {
     readonly time: number;
     readonly member: string;
     readonly text: string;
+    /** Questions the round asked, at their offsets in `text` (see RoomSpeechEvent.asks). */
+    readonly asks?: readonly {
+        readonly id: string;
+        readonly at: number;
+    }[];
     /** The member's child session (jump target), when recorded. */
     readonly childSessionId?: SessionId;
     /** Dispatch→settle milliseconds, when measured. */
@@ -37,7 +42,7 @@ export interface RoomSpeechData {
 }
 /** Chat node data of one member run row. */
 export interface RoomRunData {
-    /** Seq of the running edge's event. */
+    /** Seq the card anchors at: the running edge's event, or its latest move (`room/run-moved`). */
     readonly seq: number;
     /** Unix epoch ms from the running edge's event. */
     readonly time: number;
@@ -112,7 +117,20 @@ export interface RoomQuestionData {
     readonly questions: readonly RoomQuestionItem[];
     readonly state: 'pending' | 'answered' | 'cancelled';
     readonly answers?: readonly RoomQuestionAnswer[];
+    /** A consent gate: never answerable once it expired. */
+    readonly consent?: true;
+    /** Answered after it expired (the answers went to the member as a message). */
+    readonly late?: true;
+    /** The asker's round: the question renders inside that round (its card, then its reply), not as a row of its own. */
+    readonly runId?: string;
 }
+/**
+ * The card data of a question from the room's ask log, for the inline
+ * renderings (a round's live card and its reply).
+ * @param ask - the logged question.
+ * @returns the card data.
+ */
+export declare function askCardData(ask: RoomAsk): RoomQuestionData;
 export interface RoomRelayData {
     /** Seq of the relay's latest journal event. */
     readonly seq: number;
@@ -170,7 +188,8 @@ export declare const roomSpeechDefinition: ConversationNodeDefinition<RoomSpeech
 /**
  * The member-run Definition: one Context per run (matched on
  * member+startedAt), started by the running edge and updated by its terminal
- * edge. A running run renders the live row; a failed run stays as a dim
+ * edge. A `room/run-moved` edge re-anchors a running card (its seq, which the
+ * view orders by) below a reply or human message that landed after it. A running run renders the live row; a failed run stays as a dim
  * error row; done/cancelled hide the row IN PLACE — the assembler's live
  * incremental flush forbids withdrawing a materialized node with null (the
  * withdrawal contract is the same key with `visibility: 'hidden'`; a null

package/lib/types/client/nodes.js

@@ -1,4 +1,19 @@
 import { isAppendSurfaceEvent } from '@deepseek-ai/dsh-session/surface';
+/**
+ * The card data of a question from the room's ask log, for the inline
+ * renderings (a round's live card and its reply).
+ * @param ask - the logged question.
+ * @returns the card data.
+ */
+export function askCardData(ask) {
+    return {
+        seq: 0, time: ask.time, questionId: ask.id, member: ask.member, questions: ask.questions, state: ask.state,
+        ...ask.answers === undefined ? {} : { answers: ask.answers },
+        ...ask.consent === true ? { consent: true } : {},
+        ...ask.late === true ? { late: true } : {},
+        ...ask.runId === undefined ? {} : { runId: ask.runId },
+    };
+}
 /** The shared final-node materialization (single shape across the three kinds). */
 function viewNode(context, kind, visibility = 'visible') {
     if (context.state === undefined)
@@ -33,6 +48,7 @@ export const roomSpeechDefinition = {
             time: event.time,
             member: event.data.member,
             text: event.data.text,
+            ...event.data.asks === undefined ? {} : { asks: event.data.asks },
             ...event.data.interrupted === undefined ? {} : { interrupted: event.data.interrupted },
             ...event.data.reportedTo === undefined ? {} : { reportedTo: event.data.reportedTo },
             ...event.data.childSessionId === undefined ? {} : { childSessionId: event.data.childSessionId },
@@ -47,7 +63,8 @@ export const roomSpeechDefinition = {
 /**
  * The member-run Definition: one Context per run (matched on
  * member+startedAt), started by the running edge and updated by its terminal
- * edge. A running run renders the live row; a failed run stays as a dim
+ * edge. A `room/run-moved` edge re-anchors a running card (its seq, which the
+ * view orders by) below a reply or human message that landed after it. A running run renders the live row; a failed run stays as a dim
  * error row; done/cancelled hide the row IN PLACE — the assembler's live
  * incremental flush forbids withdrawing a materialized node with null (the
  * withdrawal contract is the same key with `visibility: 'hidden'`; a null
@@ -62,7 +79,9 @@ export const roomRunDefinition = {
             id: `${event.data.member}:${event.data.startedAt}`,
             role: event.data.state === 'running' ? 'start' : 'update',
         }
-        : null,
+        : event.type === 'room/run-moved'
+            ? { id: `${event.data.member}:${event.data.startedAt}`, role: 'update' }
+            : null,
     start: (_context, match) => {
         const event = match.event;
         if (event.type !== 'room/run-state')
@@ -77,6 +96,9 @@ export const roomRunDefinition = {
     },
     update: (context, match) => {
         const event = match.event;
+        // A move re-anchors a running card below what landed after it (the view orders by seq).
+        if (event.type === 'room/run-moved')
+            return context.state.state === 'running' ? { ...context.state, seq: event.seq } : context.state;
         if (event.type !== 'room/run-state')
             return context.state;
         const { error: _error, elapsedMs: _elapsed, ...previous } = context.state;
@@ -201,15 +223,16 @@ export const roomQuestionDefinition = {
         const event = match.event;
         if (event.type !== 'room/question')
             throw new Error('room-question start requires a room/question event');
-        return { seq: event.seq, time: event.time, questionId: event.data.id, member: event.data.member, questions: event.data.questions, state: 'pending' };
+        return { seq: event.seq, time: event.time, questionId: event.data.id, member: event.data.member, questions: event.data.questions, state: 'pending', ...event.data.consent === true ? { consent: true } : {}, ...event.data.runId === undefined ? {} : { runId: event.data.runId } };
     },
     update: (context, match) => {
         const event = match.event;
         if (event.type !== 'room/question-resolved')
             return context.state;
-        return { ...context.state, state: event.data.outcome, ...event.data.answers === undefined ? {} : { answers: event.data.answers } };
+        return { ...context.state, state: event.data.outcome, ...event.data.answers === undefined ? {} : { answers: event.data.answers }, ...event.data.late === true ? { late: true } : {} };
     },
-    buildViewNode: context => viewNode(context, 'room-question'),
+    // A question placed in a round renders inside it (RoomRunView, RoomSpeechView): its own row hides.
+    buildViewNode: context => viewNode(context, 'room-question', context.state?.runId === undefined ? 'visible' : 'hidden'),
 };
 /**
  * The relay Definition: one Context per relay (matched on the relay id),

package/lib/types/client/path-mentions.d.ts

@@ -0,0 +1,34 @@
+/**
+ * File paths a member writes in inline code (`game-2/design/art.png`) become
+ * openers, the way the main conversation links the files a turn produced.
+ * The host's own mention vocabulary (ui-deliverables) only knows files a
+ * host turn touched; a CLI member's writes happen in its own process, so the
+ * room recognizes the path's shape instead: no whitespace, no URL, a common
+ * file extension. A token that names no real file opens the viewer's
+ * "missing" state — never a broken link.
+ * @module @khorsheed/dsh-room/client/path-mentions
+ */
+import type { MarkdownFileMentions } from '@deepseek-ai/dsh-client-ui-primitives';
+/**
+ * Whether an inline-code token reads as a file path.
+ * @param value - the token as authored.
+ * @returns true for a path-shaped token with a known file extension.
+ */
+export declare function looksLikeFilePath(value: string): boolean;
+/**
+ * The absolute path a member's token names: as written when absolute, under
+ * the member's working directory when it has its own, else left relative (the
+ * file address then resolves it against the room session's workspace).
+ * @param value - the token.
+ * @param cwd - the member's own working directory, when it has one.
+ * @returns the path to open.
+ */
+export declare function memberPath(value: string, cwd: string | undefined): string;
+/**
+ * The file-mention vocabulary for one member's text.
+ * @param open - opens one resolved path in the sidebar.
+ * @param cwd - the member's own working directory, when it has one.
+ * @returns the MarkdownText fileMentions value.
+ */
+export declare function pathMentions(open: (path: string) => void, cwd: string | undefined): MarkdownFileMentions;
+//# sourceMappingURL=path-mentions.d.ts.map

package/lib/types/client/path-mentions.js

@@ -0,0 +1,39 @@
+/** Extensions a member's inline code most often names as a deliverable or source file. */
+const FILE_EXTENSION = /\.(?:png|jpe?g|gif|webp|svg|md|txt|json|ya?ml|toml|csv|html?|css|[cm]?[jt]sx?|py|sh|glb|gltf|blend|fbx|obj|mp3|wav|ogg|mp4|webm|pdf)$/i;
+/**
+ * Whether an inline-code token reads as a file path.
+ * @param value - the token as authored.
+ * @returns true for a path-shaped token with a known file extension.
+ */
+export function looksLikeFilePath(value) {
+    return value.length <= 300 && !/\s/.test(value) && !value.includes('://') && !value.startsWith('-') && FILE_EXTENSION.test(value);
+}
+/**
+ * The absolute path a member's token names: as written when absolute, under
+ * the member's working directory when it has its own, else left relative (the
+ * file address then resolves it against the room session's workspace).
+ * @param value - the token.
+ * @param cwd - the member's own working directory, when it has one.
+ * @returns the path to open.
+ */
+export function memberPath(value, cwd) {
+    if (value.startsWith('/') || value.startsWith('~') || cwd === undefined)
+        return value;
+    return `${cwd.replace(/\/+$/, '')}/${value.replace(/^\.\//, '')}`;
+}
+/**
+ * The file-mention vocabulary for one member's text.
+ * @param open - opens one resolved path in the sidebar.
+ * @param cwd - the member's own working directory, when it has one.
+ * @returns the MarkdownText fileMentions value.
+ */
+export function pathMentions(open, cwd) {
+    return {
+        resolve: (value) => {
+            if (!looksLikeFilePath(value))
+                return undefined;
+            const path = memberPath(value, cwd);
+            return { open: () => { open(path); }, label: value, title: path };
+        },
+    };
+}

package/lib/types/client/slots.d.ts

@@ -160,7 +160,49 @@ export interface RoomModelDirectory {
  * own main agent (bare messages ARE its turns); undefined on a host without
  * ui-model-selection — the picker simply does not render.
  */
+/** One unsent composer attachment (the official conversation service's draft). */
+export type RoomDraftAttachment = {
+    readonly kind: 'image';
+    readonly id: string;
+    readonly file: File;
+    readonly previewUrl: string;
+} | {
+    readonly kind: 'file';
+    readonly id: string;
+    readonly file: File;
+};
+/** A file draft's upload state (files upload on pick; images ride the send). */
+export type RoomDraftUpload = {
+    readonly status: 'uploading';
+    readonly loaded: number;
+    readonly total?: number;
+} | {
+    readonly status: 'ready';
+} | {
+    readonly status: 'error';
+    readonly message: string;
+};
+/**
+ * The official conversation service's draft-attachment face, re-used so the
+ * room's attachments pick, upload, and serialize exactly like the official
+ * composer's. Absent on a host without it: the composer offers no attachments.
+ */
+export interface RoomAttachmentsFace {
+    /** Register picked/pasted/dropped files as drafts of this session (files start uploading). */
+    readonly create: (sessionId: SessionId, files: readonly File[]) => readonly RoomDraftAttachment[];
+    readonly resolve: (ids: readonly string[]) => readonly RoomDraftAttachment[];
+    readonly release: (id: string) => void;
+    readonly retry: (sessionId: SessionId, id: string) => void;
+    readonly uploads: {
+        subscribe(listener: () => void): () => void;
+        getSnapshot(): Readonly<Record<string, RoomDraftUpload>>;
+    };
+    /** The wire form postMessage takes (images encoded, files as their upload receipts). */
+    readonly serialize: (ids: readonly string[]) => Promise<readonly import('../types.ts').RoomAttachmentInput[]>;
+}
 export interface RoomComposerInjected extends RoomGoalInjected, RoomInviteInjected {
+    /** Draft attachments; absent without the official conversation service. */
+    readonly attachments?: RoomAttachmentsFace | undefined;
     /** Open the task page (at one task); absent without the right sidebar. */
     readonly openTasks?: ((task?: string) => void) | undefined;
     /** The composer's task tag store (see task-tag.ts). */
@@ -203,7 +245,7 @@ export interface RoomComposerInjected extends RoomGoalInjected, RoomInviteInject
      * `task` is the composer's tag (`new` or a task root id): it files the
      * message under that task instead of letting dsh decide.
      */
-    readonly submit: (sessionId: SessionId, text: string, targets?: readonly string[], task?: string) => Promise<RoomMutationOutcome>;
+    readonly submit: (sessionId: SessionId, text: string, targets?: readonly string[], task?: string, attachments?: readonly import('../types.ts').RoomAttachmentInput[]) => Promise<RoomMutationOutcome>;
     /** Interrupt the room's own main-agent turn (the hidden official bar's Stop). */
     readonly stop: () => void;
     /**
@@ -323,18 +365,26 @@ export interface RoomSpeechInjected {
      * absent when the composition has no Context Lens.
      */
     readonly openDetail?: ((sessionId: SessionId, messageId: string) => void) | undefined;
+    /** Open a file path a member named in its text (sidebar file viewer); absent without the sidebar. */
+    readonly openPath?: ((sessionId: SessionId, path: string) => void) | undefined;
+    /** Answer a question asked in this round (an expired one answers late). */
+    readonly answerQuestion: RoomQuestionInjected['answerQuestion'];
 }
 /** Full props of the 'room-speech' chat-node renderer. */
 export type RoomSpeechViewProps = PropsRuntime<'conversation.chat.node', 'room-speech'> & InjectFace<RoomSpeechInjected> & PropsLocale<'room'>;
 /** Injected face of the member-run chat node. */
 export interface RoomRunInjected {
     readonly renderMemberOutput?: LocalAgentUi['renderMemberOutput'] | undefined;
+    /** Open a file path the member named while it works (sidebar file viewer). */
+    readonly openPath?: ((sessionId: SessionId, path: string) => void) | undefined;
     /** The client-side room state store (the roster carries the jump target). */
     readonly roomStore: RoomStore;
     /** Open a session (the whole-row jump into the member's child session). */
     readonly openSession: (sessionId: SessionId) => void;
     /** Cancel the named member's in-flight run through the Remote. */
     readonly cancelMember: (member: string) => Promise<void>;
+    /** Answer the question the round is waiting on, right in its live card. */
+    readonly answerQuestion: RoomQuestionInjected['answerQuestion'];
 }
 /** Full props of the 'room-run' chat-node renderer. */
 export type RoomRunViewProps = PropsRuntime<'conversation.chat.node', 'room-run'> & InjectFace<RoomRunInjected> & PropsLocale<'room'>;

package/lib/types/dispatch.d.ts

@@ -29,6 +29,56 @@ export declare function roomSource(): MessageSource;
  * member's early running edge predates the child handle's publication (the
  * terminal edge and the journal backfill cover it).
  */
+/**
+ * Keep the running members' cards at the bottom of the room's conversation:
+ * after a reply or a human message lands, each member still working gets a
+ * `room/run-moved` edge — its card re-anchors below what just landed (a
+ * typing-indicator seat), so a member that started first but is still going
+ * never reads as if it answered before the later replies. Several running
+ * members keep their start order.
+ * @param room - the room session.
+ * @param except - the member whose own reply just landed (its card ends there).
+ */
+/** How much of a round's text a question keeps to find its place in the reply later. */
+export declare const BEFORE_TAIL = 160;
+/**
+ * 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.
+ */
+export declare function roundTextSoFar(events: readonly SessionEvent[]): string;
+/**
+ * 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.
+ */
+export declare function askOffsets(events: readonly SessionEvent[], runId: string, text: string): {
+    id: string;
+    at: number;
+}[];
+/** Why a human message's move-on closes a restart-lost round (index.ts moveOnFromLostRounds). */
+export declare const MOVED_ON_TEXT = "\u4F60\u53D1\u4E86\u65B0\u6D88\u606F\uFF1B\u88AB\u91CD\u542F\u6253\u65AD\u7684\u8FD9\u4E00\u8F6E\u6309\u6CA1\u505A\u5B8C\u5904\u7406";
+/** A message that queued behind a lost round and rode along with the move-on message. */
+export declare const MERGED_BACKLOG_TEXT = "\u5DF2\u5E76\u5165\u4E0B\u4E00\u6761\u6D88\u606F\u4E00\u8D77\u9001\u8FBE";
+/** A message that queued behind a lost round an earlier move-on skipped: closed, not replayed. */
+export declare const SUPERSEDED_BACKLOG_TEXT = "\u88AB\u91CD\u542F\u6253\u65AD\u524D\u6392\u961F\uFF0C\u5DF2\u88AB\u540E\u7EED\u6D88\u606F\u53D6\u4EE3";
+/**
+ * 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.
+ */
+export declare function supersededByMoveOn(events: readonly SessionEvent[], targetId: string, dispatchSeq: number): boolean;
+export declare function floatRunningCards(room: Session, except?: string): void;
 export declare function runChildSessionId(roomId: SessionId, member: RoomMember | undefined): SessionId | undefined;
 /**
  * The child session round a run reached: the last turn/start the child wrote.
@@ -138,7 +188,17 @@ export declare class DispatchEngine {
      * 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). */
+    private readonly gateQueues;
+    /**
+     * 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.
+     */
     reportOutcome(room: Session, dispatchSeq: number, deliveryId: string, fromId: string, outcome: string, text: string): Promise<void>;
+    private gateReport;
     /**
      * Mark the relays this run delivered as sent. Delivery = the member's own
      * session received the prompt (the followup accepted / the CLI run

package/lib/types/dispatch.js

@@ -49,6 +49,106 @@ export function roomSource() {
  * member's early running edge predates the child handle's publication (the
  * terminal edge and the journal backfill cover it).
  */
+/**
+ * Keep the running members' cards at the bottom of the room's conversation:
+ * after a reply or a human message lands, each member still working gets a
+ * `room/run-moved` edge — its card re-anchors below what just landed (a
+ * typing-indicator seat), so a member that started first but is still going
+ * never reads as if it answered before the later replies. Several running
+ * members keep their start order.
+ * @param room - the room session.
+ * @param except - the member whose own reply just landed (its card ends there).
+ */
+/** How much of a round's text a question keeps to find its place in the reply later. */
+export const BEFORE_TAIL = 160;
+/**
+ * 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.
+ */
+export 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.
+ */
+export 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();
+        // Nothing said before asking: the question opens the reply.
+        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). */
+export const MOVED_ON_TEXT = '你发了新消息；被重启打断的这一轮按没做完处理';
+/** A message that queued behind a lost round and rode along with the move-on message. */
+export const MERGED_BACKLOG_TEXT = '已并入下一条消息一起送达';
+/** A message that queued behind a lost round an earlier move-on skipped: closed, not replayed. */
+export 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.
+ */
+export 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 === MOVED_ON_TEXT && event.data.dispatchSeq < dispatchSeq && dispatchSeq < event.seq);
+}
+export 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 });
+}
 export function runChildSessionId(roomId, member) {
     if (member?.kind === 'main-agent')
         return roomId;
@@ -372,6 +472,15 @@ export class DispatchEngine {
                     }
                     continue;
                 }
+                // Queued behind a restart-lost round the human has since moved on
+                // from: that move-on carries its backlog along; a row it left behind
+                // (a move-on predating the hand-over) closes as superseded instead of
+                // replaying a stale round on this access.
+                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 !== undefined && !state.deliveries?.some(row => row.memberId === targetId && (row.status === 'running' || row.status === 'uncertain')))
                     this.dispatch(room, target.name, dispatch.data.text, { dispatchSeq: dispatch.seq, targetId });
@@ -451,7 +560,28 @@ export class DispatchEngine {
      * 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 = 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);
+        void 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 === undefined)
@@ -705,6 +835,7 @@ export class DispatchEngine {
             ...lastAssistantMessageId(agent.session, before) === undefined ? {} : { messageId: lastAssistantMessageId(agent.session, before) },
             ...reportedTo === undefined ? {} : { 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', ...output === '' ? {} : { text: output } };
     }
@@ -813,9 +944,11 @@ export class DispatchEngine {
         const reportedTo = dispatchSeq === undefined ? undefined : reportRecipient(room.snapshotEvents(), dispatchSeq)?.name;
         // The member's own closing message: per-message tools address it in its session.
         const closingMessageId = lastAssistantMessageId(this.ctx.sessions.get(run.id));
+        const asks = askOffsets(room.snapshotEvents(), runId, output);
         const speech = output !== '' || interrupted === undefined ? 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 === undefined ? {} : { messageId: closingMessageId },
@@ -823,8 +956,10 @@ export class DispatchEngine {
             ...interrupted === undefined ? {} : { interrupted },
             ...reportedTo === undefined ? {} : { reportedTo },
         }) : undefined;
-        if (speech !== undefined)
+        if (speech !== undefined) {
+            floatRunningCards(room, speech.data.member);
             await this.ctx.sessions.flush(room);
+        }
         if (result.stopReason === 'completed') {
             await this.ctx.sessions.flush(room);
             return { state: 'done', text: runOutputText(result.output) };