@khorsheed/dsh-room 0.2.2 → 0.2.4

package/lib/types/index.js

@@ -42,7 +42,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 };
 /**
  * room host half: the `room` Typert Remote service. (The `room_invite` /
- * `room_task` / `room_message` model tools left this package's profile-root
+ * `room_message` / `room_read` / `room_plan` model tools left this package's profile-root
  * registration in the M4' tool-row split — their definition factories live
  * in ./tool-definition.ts and the package's own `./tool` composition entry
  * mounts them inside agent-preset compositions.) The room's entire state is the session's `room/*` custom-event
@@ -83,25 +83,121 @@ const catalogModule = await import(__rewriteRelativeImportExtension(catalogSpeci
     .catch(() => import('@deepseek-ai/dsh-session'));
 for (const type of ROOM_EVENT_TYPES)
     catalogModule.KNOWN_SESSION_EVENT_TYPES.add(type);
-import { composeRoomAgent, deriveSessionPreset, inspectCold, preloadPresetDerivationHost, presetDerivationHost, roomSessionPreset } from './agent-setup.js';
+import { composeRoomAgent, deriveSessionPreset, probeAgentPresets, inspectCold, preloadPresetDerivationHost, presetDerivationHost, roomSessionPreset } from './agent-setup.js';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import { probeLocalAgent, probeLocalAgentRoster } from './adapter.js';
-import { DispatchEngine, isRoomSource } from './dispatch.js';
-import { coordinatorMember, memberId, isRoomLog, MAIN_AGENT_MEMBER, parseMentions, replay, ROOM_EVENT_TYPES } from './journal.js';
+import { DispatchEngine, 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';
+import { resolveTaskRef } from './jobs.js';
+import { suggestTask } from './report-gate.js';
+import { decisionRecord } from './decisions.js';
+import { askerPrompt, claimed, helperTools, helpMessage, memberFromLabel, mentionedSessions, messagePrompt, readHelpSource, receivedHelps, referencedSessions, replayHelps, requestPrompt, turnAnswer } from './help.js';
 export { MAIN_AGENT_MEMBER, ROOM_EVENT_TYPES } from './journal.js';
 /** Addressing/display names must stay parseable by the composer @-grammar. */
 function validName(name) {
     return name !== '' && !/\s/.test(name) && !name.includes('@');
 }
 /** A task title is the dispatch text's first line, truncated. */
-function taskTitle(text) {
-    const first = text.trim().split('\n', 1)[0] ?? '';
-    return first.length > 60 ? `${first.slice(0, 60)}…` : first;
+/**
+ * The receipt a sending model reads back: the message id and what happens
+ * next, or why it waits.
+ */
+/** How long a member's question card waits for the human before its call gives up. */
+const QUESTION_TIMEOUT_MS = 30 * 60_000;
+/**
+ * Validate a member's `ask_user_question` questions: an array, or that array
+ * as JSON text (some models only send flat strings). Options may be labels or
+ * `{ label, description }`; `multi_select` (the host tool's spelling) or
+ * `multiSelect` marks a multi-pick question.
+ * @param raw - the tool argument.
+ * @returns the questions, or the error text the model reads.
+ */
+export function parseQuestions(raw) {
+    let value = raw;
+    if (typeof value === 'string') {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return 'questions must be an array (or its JSON text)';
+        }
+    }
+    if (!Array.isArray(value) || value.length === 0)
+        return 'questions must be a non-empty array';
+    if (value.length > 4)
+        return 'Ask at most 4 questions at a time';
+    const questions = [];
+    for (const [index, entry] of value.entries()) {
+        if (entry === null || typeof entry !== 'object')
+            return `questions[${index}] must be an object`;
+        const row = entry;
+        if (typeof row.question !== 'string' || row.question.trim() === '')
+            return `questions[${index}].question is required`;
+        const options = [];
+        for (const option of Array.isArray(row.options) ? row.options : []) {
+            const label = typeof option === 'string' ? option : option?.label;
+            if (typeof label !== 'string' || label.trim() === '')
+                continue;
+            const description = typeof option === 'object' && option !== null && typeof option.description === 'string' ? option.description.trim() : '';
+            options.push({ label: label.trim().slice(0, 200), ...description === '' ? {} : { description: description.slice(0, 500) } });
+        }
+        if (options.length > 8)
+            return `questions[${index}] has more than 8 options`;
+        const id = typeof row.id === 'string' && row.id.trim() !== '' ? row.id.trim() : `q${index + 1}`;
+        const header = typeof row.header === 'string' && row.header.trim() !== '' ? row.header.trim().slice(0, 40) : undefined;
+        const multiSelect = row.multi_select === true || row.multiSelect === true;
+        questions.push({ id, question: row.question.trim().slice(0, 2000), ...header === undefined ? {} : { header }, ...options.length === 0 ? {} : { options }, ...multiSelect ? { multiSelect } : {} });
+    }
+    if (new Set(questions.map(question => question.id)).size !== questions.length)
+        return 'Question ids must be unique';
+    return questions;
+}
+function messageReceipt(receipt, kind) {
+    if (receipt.held !== undefined) {
+        const why = receipt.held === 'paused' ? '房间已暂停，恢复后自动投递'
+            : receipt.held === 'hop-limit' ? '这条消息链已到跳数上限，等房间主人决定是否继续'
+                : '房间设置为成员间消息需房间主人确认';
+        return `pending-confirm （${why}）`;
+    }
+    return kind === 'notify'
+        ? `sent #${receipt.messageId}（知会，不会回报）`
+        : `sent #${receipt.messageId}（${receipt.member} 做完后结果会自动回报给你；不要 sleep 等待，也不要用 room_read 轮询）`;
+}
+/** The message-tools edit trigger (data only — no dependency on that plugin). */
+function isEditTrigger(source) {
+    return source.kind === 'message-tools' && source.op === 'edit-trigger';
+}
+/** Whether a user/message is message-tools' in-place edit of a human message. */
+function editedText(source) {
+    return source.kind === 'message-tools' && source.op === 'edit';
+}
+/** A message's text blocks, joined. */
+function textBlocks(content) {
+    return content.flatMap(block => block.type === 'text' && typeof block.text === 'string' ? [block.text] : []).join('\n').trim();
+}
+/**
+ * What a new coordinator reads once, on its first round: who handed over,
+ * the goal and open tasks, and where to look. The conversation itself is
+ * not replayed — a member that was in the room has most of it already, and
+ * re-sending it cost a five-figure prompt; it reads the room when it needs to.
+ */
+export function handoffText(_events, state, sessionId, from, to) {
+    const open = (state.jobs ?? []).filter(job => job.status === 'running' || job.status === 'attention');
+    return [
+        `【协调者交接】${from} 把协调者交给了你（${to}）。从现在起，人发的不带 @ 的消息都由你来接。`,
+        `房间会话：${sessionId}。各成员之前的原生会话都还在，可按会话 ID 查看；完整状态用 room_read。`,
+        state.goal === undefined ? '' : `房间目标：${state.goal}`,
+        state.plan === undefined ? '' : `正式目标 ${state.plan.id}（第 ${state.plan.revision} 版）：${state.plan.objective}（${state.plan.status}）。尝试、证据、依赖和预算用 room_read 查看；保持当前的暂停状态。`,
+        ...open.map(job => `进行中的任务 ${job.number}（${job.status === 'attention' ? '需要人处理' : '进行中'}）：${job.title}`),
+        '之前的对话没有附上：需要时用 room_read，或打开房间会话自己看。',
+    ].filter(Boolean).join('\n').slice(0, 16000);
 }
 /**
  * room Remote service: promotion, roster management, the human @-message
- * intake, the notification gate, the task board, and run cancellation. A
+ * intake, the notification gate, tasks, and run cancellation. A
  * room IS a normal session; the journal is its only state. A room is never
  * CREATED apart from a session — inviting an agent into any session promotes
  * it (see ensureRoom; the room-session-promotion proposal).
@@ -111,6 +207,8 @@ let RoomService = (() => {
     let _instanceExtraInitializers = [];
     let _isRoom_decorators;
     let _listProviders_decorators;
+    let _setTaskHint_decorators;
+    let _stopJob_decorators;
     let _getState_decorators;
     let _invite_decorators;
     let _updateMember_decorators;
@@ -118,12 +216,18 @@ let RoomService = (() => {
     let _reconcileDelivery_decorators;
     let _setCoordinator_decorators;
     let _removeMember_decorators;
+    let _restoreMember_decorators;
     let _postMessage_decorators;
     let _planCommand_decorators;
+    let _answerApproval_decorators;
+    let _answerQuestion_decorators;
     let _confirmRelay_decorators;
+    let _releaseReports_decorators;
+    let _setSettings_decorators;
+    let _linkSession_decorators;
+    let _unlinkSession_decorators;
+    let _dismissHelpNudge_decorators;
     let _dismissRelay_decorators;
-    let _addTask_decorators;
-    let _closeTask_decorators;
     let _setGoal_decorators;
     let _cancel_decorators;
     let _cancelChild_decorators;
@@ -132,6 +236,8 @@ let RoomService = (() => {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             _isRoom_decorators = [Remote('isRoom')];
             _listProviders_decorators = [Remote('listProviders')];
+            _setTaskHint_decorators = [Remote('setTaskHint')];
+            _stopJob_decorators = [Remote('stopJob')];
             _getState_decorators = [Remote('getState')];
             _invite_decorators = [Remote('invite')];
             _updateMember_decorators = [Remote('updateMember')];
@@ -139,17 +245,25 @@ let RoomService = (() => {
             _reconcileDelivery_decorators = [Remote('reconcileDelivery')];
             _setCoordinator_decorators = [Remote('setCoordinator')];
             _removeMember_decorators = [Remote('removeMember')];
+            _restoreMember_decorators = [Remote('restoreMember')];
             _postMessage_decorators = [Remote('postMessage')];
             _planCommand_decorators = [Remote('planCommand')];
+            _answerApproval_decorators = [Remote('answerApproval')];
+            _answerQuestion_decorators = [Remote('answerQuestion')];
             _confirmRelay_decorators = [Remote('confirmRelay')];
+            _releaseReports_decorators = [Remote('releaseReports')];
+            _setSettings_decorators = [Remote('setSettings')];
+            _linkSession_decorators = [Remote('linkSession')];
+            _unlinkSession_decorators = [Remote('unlinkSession')];
+            _dismissHelpNudge_decorators = [Remote('dismissHelpNudge')];
             _dismissRelay_decorators = [Remote('dismissRelay')];
-            _addTask_decorators = [Remote('addTask')];
-            _closeTask_decorators = [Remote('closeTask')];
             _setGoal_decorators = [Remote('setGoal')];
             _cancel_decorators = [Remote('cancel')];
             _cancelChild_decorators = [Remote('cancelChild')];
             __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);
+            __esDecorate(this, null, _stopJob_decorators, { kind: "method", name: "stopJob", static: false, private: false, access: { has: obj => "stopJob" in obj, get: obj => obj.stopJob }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getState_decorators, { kind: "method", name: "getState", static: false, private: false, access: { has: obj => "getState" in obj, get: obj => obj.getState }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _invite_decorators, { kind: "method", name: "invite", static: false, private: false, access: { has: obj => "invite" in obj, get: obj => obj.invite }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _updateMember_decorators, { kind: "method", name: "updateMember", static: false, private: false, access: { has: obj => "updateMember" in obj, get: obj => obj.updateMember }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -157,12 +271,18 @@ let RoomService = (() => {
             __esDecorate(this, null, _reconcileDelivery_decorators, { kind: "method", name: "reconcileDelivery", static: false, private: false, access: { has: obj => "reconcileDelivery" in obj, get: obj => obj.reconcileDelivery }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _setCoordinator_decorators, { kind: "method", name: "setCoordinator", static: false, private: false, access: { has: obj => "setCoordinator" in obj, get: obj => obj.setCoordinator }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _removeMember_decorators, { kind: "method", name: "removeMember", static: false, private: false, access: { has: obj => "removeMember" in obj, get: obj => obj.removeMember }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _restoreMember_decorators, { kind: "method", name: "restoreMember", static: false, private: false, access: { has: obj => "restoreMember" in obj, get: obj => obj.restoreMember }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _postMessage_decorators, { kind: "method", name: "postMessage", static: false, private: false, access: { has: obj => "postMessage" in obj, get: obj => obj.postMessage }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _planCommand_decorators, { kind: "method", name: "planCommand", static: false, private: false, access: { has: obj => "planCommand" in obj, get: obj => obj.planCommand }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _answerApproval_decorators, { kind: "method", name: "answerApproval", static: false, private: false, access: { has: obj => "answerApproval" in obj, get: obj => obj.answerApproval }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _answerQuestion_decorators, { kind: "method", name: "answerQuestion", static: false, private: false, access: { has: obj => "answerQuestion" in obj, get: obj => obj.answerQuestion }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _confirmRelay_decorators, { kind: "method", name: "confirmRelay", static: false, private: false, access: { has: obj => "confirmRelay" in obj, get: obj => obj.confirmRelay }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _releaseReports_decorators, { kind: "method", name: "releaseReports", static: false, private: false, access: { has: obj => "releaseReports" in obj, get: obj => obj.releaseReports }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setSettings_decorators, { kind: "method", name: "setSettings", static: false, private: false, access: { has: obj => "setSettings" in obj, get: obj => obj.setSettings }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _linkSession_decorators, { kind: "method", name: "linkSession", static: false, private: false, access: { has: obj => "linkSession" in obj, get: obj => obj.linkSession }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _unlinkSession_decorators, { kind: "method", name: "unlinkSession", static: false, private: false, access: { has: obj => "unlinkSession" in obj, get: obj => obj.unlinkSession }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _dismissHelpNudge_decorators, { kind: "method", name: "dismissHelpNudge", static: false, private: false, access: { has: obj => "dismissHelpNudge" in obj, get: obj => obj.dismissHelpNudge }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _dismissRelay_decorators, { kind: "method", name: "dismissRelay", static: false, private: false, access: { has: obj => "dismissRelay" in obj, get: obj => obj.dismissRelay }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _addTask_decorators, { kind: "method", name: "addTask", static: false, private: false, access: { has: obj => "addTask" in obj, get: obj => obj.addTask }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _closeTask_decorators, { kind: "method", name: "closeTask", static: false, private: false, access: { has: obj => "closeTask" in obj, get: obj => obj.closeTask }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _setGoal_decorators, { kind: "method", name: "setGoal", static: false, private: false, access: { has: obj => "setGoal" in obj, get: obj => obj.setGoal }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _cancel_decorators, { kind: "method", name: "cancel", static: false, private: false, access: { has: obj => "cancel" in obj, get: obj => obj.cancel }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _cancelChild_decorators, { kind: "method", name: "cancelChild", static: false, private: false, access: { has: obj => "cancelChild" in obj, get: obj => obj.cancelChild }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -173,6 +293,19 @@ let RoomService = (() => {
         plans = __runInitializers(this, _instanceExtraInitializers);
         engine;
         handoffs = new Set();
+        /**
+         * The terminal run-state fields Context Lens correlates on: the child
+         * identity plus the round the run reached (live sessions only).
+         */
+        terminalRunStateFields(session, state, memberName) {
+            const member = state.members.find(entry => entry.name === memberName);
+            const childSessionId = runChildSessionId(session.id, member);
+            const childTurn = runChildTurn(childSessionId === undefined ? undefined : this.ctx.sessions.get(childSessionId));
+            return {
+                ...childSessionId === undefined ? {} : { childSessionId },
+                ...childTurn === undefined ? {} : { childTurn },
+            };
+        }
         /** sessionId → in-flight cold resume (mutations on a cold room dedupe). */
         resumes = new Map();
         /**
@@ -205,9 +338,53 @@ let RoomService = (() => {
             this.engine = new DispatchEngine(ctx, {
                 allows: (room, seq) => this.plans.allows(room, seq),
                 admitted: (room, seq) => this.plans.admitted(room, seq),
-                settled: (room, seq, outcome) => this.plans.settled(room, seq, outcome),
+                settled: async (room, seq, outcome) => {
+                    await this.plans.settled(room, seq, outcome);
+                    void this.helpSettled(room, seq, outcome).catch((error) => { this.ctx.logger.warn(`room: help reply faulted: ${String(error)}`); });
+                },
             });
             ctx.effect(() => () => this.plans.dispose());
+            // The human talking to the room's own agent directly (the official input
+            // path): file the message under a task before the model reads it — the
+            // composer's tag, else the decision model while tasks are open — and tell
+            // the coordinator when it was filed under an existing task.
+            ctx.on('agent/pre-step', async ({ agent, step }, next) => {
+                const decision = await next();
+                if (step !== 1 || decision.kind !== 'enter')
+                    return decision;
+                const events = agent.session.snapshotEvents();
+                if (!isRoomLog(events) || coordinatorMember(replay(events), events)?.kind !== 'main-agent')
+                    return decision;
+                const notes = [];
+                for (const message of decision.messages) {
+                    if (message.source.kind !== 'user')
+                        continue;
+                    const text = message.content.flatMap(block => block.type === 'text' ? [block.text] : []).join('\n');
+                    const filed = await this.fileHumanMessage(agent.session, message.id, text, this.consumeTaskHint(agent.session.id));
+                    if (filed.note !== undefined)
+                        notes.push(filed.note);
+                }
+                if (notes.length === 0)
+                    return decision;
+                return { ...decision, messages: [...decision.messages, createUserMessage({ content: [{ type: 'text', text: notes.join('\n') }], source: roomSource() })] };
+            });
+            // A turn the room did not start (the human talking to the room's agent or
+            // to a native member directly) still carries the reports the gate holds
+            // for that agent: one extra message on the turn's first step, so the
+            // agent never answers without results that already arrived.
+            ctx.on('agent/pre-step', async ({ agent, step }, next) => {
+                const decision = await next();
+                if (step !== 1 || decision.kind !== 'enter' || decision.messages.some(message => isRoomSource(message.source)))
+                    return decision;
+                const target = this.heldTarget(agent.session.id);
+                if (target === undefined)
+                    return decision;
+                const held = heldReportsText(target.room.snapshotEvents(), memberId(target.room.snapshotEvents(), target.member));
+                if (held === undefined)
+                    return decision;
+                await this.engine.markHeldReleased(target.room, target.member, held.seqs);
+                return { ...decision, messages: [createUserMessage({ content: [{ type: 'text', text: held.text }], source: roomSource() }), ...decision.messages] };
+            });
             // A stale client or another official input surface must not wake a DSH
             // model behind an external coordinator. Public pre-step admits an empty
             // initial step without a model call after room has durably accepted it.
@@ -224,6 +401,16 @@ let RoomService = (() => {
                     nativeTurns.set(agent, turn);
                     return next();
                 }
+                // An edit of the human's message (message-tools) wakes this agent to
+                // answer again; behind an external coordinator the edited text goes
+                // to the coordinator through the room instead.
+                const trigger = messages.find(message => isEditTrigger(message.source));
+                if (trigger !== undefined) {
+                    const routed = await this.routeEdit(agent.session, String(trigger.id));
+                    if (!routed.ok)
+                        throw new Error(`Room input routing failed: ${routed.code}`);
+                    return { kind: 'enter', messages: [] };
+                }
                 for (const message of messages) {
                     if (message.source.kind !== 'user' || message.content.some(block => block.type !== 'text')) {
                         throw new Error('Use the room input route for this coordinator; this input cannot be forwarded losslessly');
@@ -234,6 +421,31 @@ let RoomService = (() => {
                 }
                 return { kind: 'enter', messages: [] };
             });
+            // 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
+            // agent-local tools) is equipped on its first step.
+            const scanned = new WeakSet();
+            ctx.on('agent/pre-step', async ({ agent, step }, next) => {
+                const decision = await next();
+                if (decision.kind !== 'enter')
+                    return decision;
+                const arriving = decision.messages.flatMap((message) => {
+                    const source = readHelpSource(message.source);
+                    return source === undefined ? [] : [source];
+                });
+                if (arriving.length > 0) {
+                    this.equipHelper(agent);
+                    for (const source of arriving)
+                        await this.markHelpRunning(source);
+                }
+                else if (step === 1 && !scanned.has(agent)) {
+                    scanned.add(agent);
+                    if (receivedHelps(agent.session.snapshotEvents()).length > 0)
+                        this.equipHelper(agent);
+                }
+                return decision;
+            });
             // The model-facing room tools are deliberately NOT registered here: they
             // belong to this package's `./tool` composition entry (src/tool.ts),
             // which mounts the tool row inside agent-preset compositions
@@ -285,6 +497,8 @@ let RoomService = (() => {
                 return (async () => {
                     await this.plans.recover(hit.session);
                     await this.engine.recover(hit.session);
+                    this.expireApprovals(hit.session);
+                    this.expireQuestions(hit.session);
                     return this.load(sessionId);
                 })();
             if (hit.error.code !== 'session-not-found')
@@ -315,8 +529,10 @@ let RoomService = (() => {
             if (loaded.ok) {
                 await this.plans.recover(loaded.session);
                 await this.engine.recover(loaded.session);
+                this.expireApprovals(loaded.session);
+                this.expireQuestions(loaded.session);
             }
-            return loaded;
+            return this.load(sessionId);
         }
         /**
          * Probe whether a session is a room: replay its event log looking for the
@@ -373,11 +589,14 @@ let RoomService = (() => {
          * @param _request - no parameters.
          * @returns the provider list and the facade verdict.
          */
-        async listProviders(_request) {
+        async listProviders(request) {
             const localAgentAvailable = probeLocalAgent(this.ctx) !== undefined;
+            const listed = await this.listPresets();
+            const sessionPreset = request.sessionId === undefined || listed === undefined ? undefined : await this.sessionPreset(request.sessionId);
+            const presets = listed === undefined ? {} : { presets: listed, ...sessionPreset === undefined ? {} : { sessionPreset } };
             const roster = probeLocalAgentRoster(this.ctx);
             if (roster === undefined)
-                return { localAgentAvailable, providers: [] };
+                return { localAgentAvailable, providers: [], ...presets };
             const providers = [];
             for (const row of roster.roster()) {
                 const status = await roster.statusOf(row.name);
@@ -393,7 +612,273 @@ let RoomService = (() => {
                     authenticated: status.authenticated,
                 });
             }
-            return { localAgentAvailable, providers };
+            return { localAgentAvailable, providers, ...presets };
+        }
+        /** A session's own mode (preset id), live or cold; undefined when unreadable. */
+        async sessionPreset(sessionId) {
+            try {
+                const live = this.ctx.sessions.get(sessionId);
+                if (live !== undefined)
+                    return roomSessionPreset(live);
+                const inspected = await inspectCold(this.ctx, sessionId);
+                return inspected === undefined ? undefined : deriveSessionPreset(presetDerivationHost(), { header: inspected.meta, events: inspected.events });
+            }
+            catch {
+                return undefined;
+            }
+        }
+        /** The host's agent presets for a native member, or undefined without a registry. */
+        async listPresets() {
+            const presets = probeAgentPresets(this.ctx);
+            if (presets?.list === undefined)
+                return undefined;
+            try {
+                const fallback = (await presets.resolve()).id;
+                return (await presets.list()).map(row => ({
+                    id: row.id, isDefault: row.id === fallback,
+                    ...row.name === undefined ? {} : { name: row.name },
+                    ...row.description === undefined ? {} : { description: row.description },
+                    ...row.broken === undefined ? {} : { broken: row.broken },
+                }));
+            }
+            catch {
+                return undefined;
+            }
+        }
+        /** The composer's task tags, consumed by the human's next message in that room. */
+        taskHints = new Map();
+        consumeTaskHint(sessionId) {
+            const hint = this.taskHints.get(sessionId);
+            this.taskHints.delete(sessionId);
+            return hint;
+        }
+        /**
+         * File a new human message under a task: the composer's tag when given
+         * (a task root id, or `new`), otherwise — while some task is still open —
+         * the decision model's suggestion; with neither it starts a task of its own.
+         * A filing other than its own task is journaled as a `room/task-link`.
+         * @returns the task root id and, for a model suggestion, the note the coordinator should read.
+         */
+        async fileHumanMessage(session, messageId, text, tag) {
+            const jobs = replay(session.snapshotEvents()).jobs ?? [];
+            if (tag === 'new')
+                return { task: messageId };
+            if (tag !== undefined) {
+                const target = jobs.find(job => job.id === tag);
+                if (target === undefined)
+                    return { task: messageId };
+                session.append('room/task-link', { message: messageId, task: target.id, by: 'human' });
+                return { task: target.id, note: `【任务归属】这条消息是用户在任务页对「任务 ${target.number}：${target.title}」的追问。` };
+            }
+            const open = jobs.filter(job => job.status === 'running' || job.status === 'attention');
+            const events = session.snapshotEvents();
+            const state = replay(events);
+            // Nothing to file into, or automatic filing switched off: a task of its own.
+            if (open.length === 0 || state.settings?.autoTaskFiling === false)
+                return { task: messageId };
+            const suggestion = await suggestTask(this.ctx, text, open.map(job => ({
+                number: job.number, title: job.title,
+                running: (state.deliveries ?? []).filter(row => job.deliveries.includes(row.id) && (row.status === 'running' || row.status === 'queued'))
+                    .map(row => state.members.find(member => memberId(events, member) === row.memberId)?.name ?? row.memberId),
+            })));
+            const target = suggestion.task === 'new' ? undefined : jobs.find(job => job.number === suggestion.task);
+            // Every filing that weighed the open tasks is recorded (the timeline row, Context Lens).
+            session.append('room/decision', decisionRecord('task-filing', {
+                outcome: target === undefined ? 'new' : String(target.number),
+                ...suggestion.rule === undefined ? {} : { rule: suggestion.rule },
+                ...suggestion.probability === undefined ? {} : { probability: suggestion.probability },
+                ...suggestion.call === undefined ? {} : { call: suggestion.call },
+                about: { message: messageId, ...target === undefined ? {} : { task: { number: target.number, title: target.title.slice(0, 200) } } },
+            }));
+            if (target === undefined)
+                return { task: messageId };
+            const probability = suggestion.probability ?? 0;
+            session.append('room/task-link', { message: messageId, task: target.id, by: 'model', probability });
+            return { task: target.id, note: `【任务归属】这条消息看起来是在接着做「任务 ${target.number}：${target.title}」（判断置信 ${probability.toFixed(2)}）。如果不对，派活时用 task: "new" 或别的任务编号指明，房间会改过来。` };
+        }
+        /**
+         * Tag the human's next message with a task (the task page's 追问 /
+         * 新任务), or clear the tag.
+         * @param request - room session and the task root id, `new`, or null.
+         * @returns acknowledgement.
+         */
+        async setTaskHint(request) {
+            if (request.task === null)
+                this.taskHints.delete(request.sessionId);
+            else
+                this.taskHints.set(request.sessionId, request.task);
+            return { ok: true };
+        }
+        /**
+         * Stop a whole task: running rounds of its deliveries are cancelled (the
+         * same cancel the stop button uses), queued and held ones never run, and
+         * ordinary rounds whose outcome a restart lost close as cancelled — the
+         * human gave up on them — which unblocks those members' later messages.
+         * @param request - room session and the task root id.
+         * @returns how many deliveries were stopped.
+         */
+        async stopJob(request) {
+            const loaded = await this.ensureLive(request.sessionId);
+            if (!loaded.ok)
+                return { ok: false, error: loaded.error };
+            const job = loaded.state.jobs?.find(entry => entry.id === request.task);
+            if (job === undefined)
+                return { ok: false, error: { code: 'unknown-task' } };
+            let stopped = 0;
+            for (const row of loaded.state.deliveries ?? []) {
+                if (!job.deliveries.includes(row.id))
+                    continue;
+                if (row.status === 'running') {
+                    const member = loaded.state.members.find(entry => (entry.id ?? entry.name) === row.memberId);
+                    if (member !== undefined && (await this.cancel({ sessionId: request.sessionId, name: member.name, expectedRunId: row.id })).ok)
+                        stopped++;
+                }
+                else if (row.status === 'queued' || row.status === 'held') {
+                    loaded.session.append('room/delivery-state', { id: row.id, dispatchSeq: row.dispatchSeq, memberId: row.memberId, state: 'cancelled', error: '任务已被停止' });
+                    stopped++;
+                }
+                else if (row.status === 'uncertain' && row.plan?.taskId === undefined) {
+                    // Stopping is the human abandoning the round whose outcome a restart
+                    // lost: that settles it, so the member's later messages run again.
+                    loaded.session.append('room/delivery-state', { id: row.id, dispatchSeq: row.dispatchSeq, memberId: row.memberId, state: 'cancelled', text: '任务已被停止；这一轮的结果没有核对' });
+                    const run = loaded.state.runs.find(entry => entry.runId === row.id);
+                    if (run !== undefined)
+                        loaded.session.append('room/run-state', { member: run.member, runId: row.id, startedAt: run.startedAt, state: 'cancelled', ...this.terminalRunStateFields(loaded.session, loaded.state, run.member) });
+                    stopped++;
+                }
+            }
+            loaded.session.append('room/job-stopped', { task: job.id });
+            await this.ctx.sessions.flush(loaded.session);
+            await this.engine.recover(loaded.session);
+            return { ok: true, value: { stopped } };
+        }
+        /**
+         * Route the human's edited message (message-tools replaced the bubble in
+         * place) to the room: the original message's dispatch stops — editing is
+         * changing one's mind — and the edited text dispatches like a new human
+         * message, filed under the original's task, without a second bubble.
+         * Idempotent per edit trigger.
+         */
+        async routeEdit(session, requestId) {
+            const events = session.snapshotEvents();
+            if (events.some(event => event.type === 'room/dispatch' && event.data.id === requestId))
+                return { ok: true };
+            const edit = events.findLast(event => event.type === 'user/message' && editedText(event.data.source));
+            if (edit?.type !== 'user/message')
+                return { ok: false, code: 'edit-not-found' };
+            const text = textBlocks(edit.data.content);
+            if (text === '')
+                return { ok: false, code: 'empty-text' };
+            const replaced = edit.sourceEventSeqs ?? [];
+            const originals = events.filter(event => replaced.includes(event.seq) && isHumanMessage(event));
+            const links = taskLinks(events);
+            const task = originals.length === 0 ? undefined : linkedTask(links, originals[0].type === 'user/message' ? originals[0].data.id : '');
+            // The original's dispatch: the human dispatch that followed it.
+            const state = replay(events);
+            for (const original of originals) {
+                const next = events.find(event => event.seq > original.seq && (event.type === 'room/dispatch' || isHumanMessage(event)));
+                if (next?.type !== 'room/dispatch' || next.data.origin !== 'human')
+                    continue;
+                for (const row of (state.deliveries ?? []).filter(entry => entry.dispatchSeq === next.seq)) {
+                    const member = state.members.find(entry => memberId(events, entry) === row.memberId);
+                    if (row.status === 'running' && member !== undefined)
+                        await this.cancel({ sessionId: session.id, name: member.name, expectedRunId: row.id });
+                    else if (row.status === 'queued' || row.status === 'held')
+                        session.append('room/delivery-state', { id: row.id, dispatchSeq: row.dispatchSeq, memberId: row.memberId, state: 'cancelled', error: '你编辑了这条消息' });
+                }
+            }
+            const parsed = parseMentions(text);
+            const targets = [...parsed.targets];
+            const current = replay(session.snapshotEvents());
+            if (targets.length === 0) {
+                const coordinator = coordinatorMember(current, session.snapshotEvents());
+                if (coordinator === undefined)
+                    return { ok: false, code: 'member-not-found' };
+                targets.push(coordinator.name);
+            }
+            if (targets.some(target => !current.members.some(member => member.name === target)))
+                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 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 });
+            return { ok: true };
+        }
+        /**
+         * The human messaging a member moves on from that member's ordinary
+         * rounds a restart left uncertain: they close as not finished, so the new
+         * message runs instead of queueing behind a reconciliation. Formal-goal
+         * attempts keep their explicit reconciliation.
+         */
+        moveOnFromLostRounds(session, targets, why = '你发了新消息；被重启打断的这一轮按没做完处理') {
+            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)));
+            for (const row of state.deliveries ?? []) {
+                if (row.status !== 'uncertain' || row.plan?.taskId !== undefined || !ids.has(row.memberId))
+                    continue;
+                session.append('room/delivery-state', { id: row.id, dispatchSeq: row.dispatchSeq, memberId: row.memberId, state: 'cancelled', text: why });
+                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) });
+            }
+        }
+        /**
+         * Where a member's next send belongs: the task and delivery it is working
+         * on (a member inside a room round), or — for the room's own agent answering
+         * the human directly — the task of the human message that started its turn
+         * (`trigger`, which the coordinator may re-file with `task`).
+         */
+        sendContext(session, sender) {
+            const events = session.snapshotEvents();
+            const state = replay(events);
+            const run = state.runs.find(entry => entry.member === sender.name && entry.state === 'running');
+            const row = run?.runId === undefined ? undefined : state.deliveries?.find(entry => entry.id === run.runId);
+            if (row !== undefined)
+                return { ...row.task === undefined ? {} : { task: row.task }, parent: row.id };
+            if (sender.kind !== 'main-agent')
+                return {};
+            const human = events.findLast(isHumanMessage);
+            if (human === undefined)
+                return {};
+            return { task: linkedTask(taskLinks(events), human.data.id), trigger: human.data.id };
+        }
+        /** The room and member whose held reports a session's agent should carry. */
+        heldTarget(sessionId) {
+            const own = this.ctx.sessions.get(SessionId(sessionId));
+            if (own !== undefined && isRoomLog(own.snapshotEvents())) {
+                const member = replay(own.snapshotEvents()).members.find(entry => entry.kind === 'main-agent');
+                return member === undefined ? undefined : { room: own, member };
+            }
+            const routed = this.nativeRoute(sessionId);
+            const room = routed === undefined ? undefined : this.ctx.sessions.get(routed.roomId);
+            const member = room === undefined ? undefined : replay(room.snapshotEvents()).members.find(entry => entry.childSessionId === routed.actor);
+            return room === undefined || member === undefined ? undefined : { room, member };
+        }
+        /**
+         * A native member's own session calling a room tool: the tools see the
+         * child session, so route to its room with the child as the authenticated
+         * actor instead of promoting the child into a room of its own.
+         * @param sessionId - the calling agent's session.
+         * @returns the room and actor, or undefined when the caller is no native member.
+         */
+        nativeRoute(sessionId) {
+            const parent = this.ctx.sessions.get(SessionId(sessionId))?.header.parentSession;
+            const room = parent === undefined ? undefined : this.ctx.sessions.get(parent);
+            if (room === undefined || parent === undefined)
+                return undefined;
+            const events = room.snapshotEvents();
+            if (!isRoomLog(events))
+                return undefined;
+            return replay(events).members.some(member => member.kind === 'native' && member.childSessionId === sessionId)
+                ? { roomId: parent, actor: sessionId }
+                : undefined;
         }
         /**
          * Replay the room's journal into the derived state (roster, notification
@@ -406,6 +891,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) } } };
         }
         /**
@@ -427,6 +918,9 @@ let RoomService = (() => {
          * @returns the invitation receipt, or a rejection.
          */
         async inviteMember(request, invitedBy, actorChildSessionId) {
+            const routed = invitedBy === 'agent' && actorChildSessionId === undefined ? this.nativeRoute(request.sessionId) : undefined;
+            if (routed !== undefined)
+                return this.inviteMember({ ...request, sessionId: routed.roomId }, invitedBy, routed.actor);
             // Invite PROMOTES: inviting an agent into a plain session makes it a room.
             const loaded = await this.ensureRoom(request.sessionId);
             if (!loaded.ok)
@@ -448,23 +942,59 @@ let RoomService = (() => {
             if (request.firstTask !== undefined && request.firstTask.trim() === '') {
                 return { ok: false, error: { code: 'empty-text' } };
             }
+            if (request.role !== undefined && request.role.trim().length > ROOM_ROLE_MAX) {
+                return { ok: false, error: { code: 'role-too-long' } };
+            }
             if (request.model !== undefined && request.model.trim() === '') {
                 return { ok: false, error: { code: 'empty-text' } };
             }
-            if (probeLocalAgent(this.ctx) === undefined) {
+            if (request.effort !== undefined && request.effort.trim() === '') {
+                return { ok: false, error: { code: 'empty-text' } };
+            }
+            const native = request.kind === 'native';
+            // The coordinator's default: the member works in the room's own mode.
+            const inherited = request.preset === undefined && request.inheritPreset === true ? roomSessionPreset(loaded.session) : undefined;
+            if (inherited !== undefined)
+                request = { ...request, preset: inherited };
+            if (request.preset !== undefined) {
+                // A native member composes a host preset; a CLI member reaches that
+                // preset's plugin tools through its bridge. Reject an id the host does
+                // not declare instead of failing at the member's first round.
+                const presets = probeAgentPresets(this.ctx);
+                if (presets !== undefined) {
+                    try {
+                        await presets.resolve(request.preset);
+                    }
+                    catch {
+                        const available = (await presets.list?.())?.map(row => row.id) ?? [];
+                        return { ok: false, error: { code: 'unknown-preset', preset: request.preset, available } };
+                    }
+                }
+            }
+            if (!native && probeLocalAgent(this.ctx) === undefined) {
                 return { ok: false, error: { code: 'local-agent-unavailable' } };
             }
-            const roster = probeLocalAgentRoster(this.ctx);
+            const roster = native ? undefined : probeLocalAgentRoster(this.ctx);
             if (roster !== undefined) {
                 // The same delegationProvider set listProviders serves: invite accepts
                 // exactly what dispatch can resolve, and the rejection carries the
                 // legal set so a model caller can self-correct (rename and retry).
                 const available = [];
+                // The names a model reaches for first — the harness name (claude-code)
+                // and its display name (Claude Code) — resolve to the provider id.
+                const aliases = new Map();
+                const key = (name) => name.toLowerCase().replace(/[\s_-]+/g, '');
                 for (const row of roster.roster()) {
                     const status = await roster.statusOf(row.name);
-                    if (status.delegationProvider !== undefined)
-                        available.push(status.delegationProvider);
+                    if (status.delegationProvider === undefined)
+                        continue;
+                    available.push(status.delegationProvider);
+                    for (const alias of [row.name, row.displayName, status.delegationProvider])
+                        aliases.set(key(alias), status.delegationProvider);
                 }
+                const aliased = aliases.get(key(request.provider));
+                if (!available.includes(request.provider) && aliased !== undefined)
+                    request = { ...request, provider: aliased };
                 if (!available.includes(request.provider)) {
                     return { ok: false, error: { code: 'unknown-provider', provider: request.provider, available } };
                 }
@@ -478,31 +1008,40 @@ let RoomService = (() => {
             loaded.session.append('room/member-added', {
                 id: randomUUID(),
                 name: request.name,
-                kind: 'cli',
-                provider: request.provider,
+                kind: native ? 'native' : 'cli',
+                provider: native ? 'dsh' : request.provider,
+                ...request.preset !== undefined ? { preset: request.preset } : {},
                 invitedBy,
                 ...request.instructions === undefined ? {} : { instructions: request.instructions },
+                ...request.role === undefined || request.role.trim() === '' ? {} : { role: request.role.trim() },
                 ...request.cwd === undefined || request.cwd.trim() === '' ? {} : { cwd: request.cwd.trim() },
                 ...request.model === undefined || request.model.trim() === '' ? {} : { model: request.model.trim() },
+                ...request.effort === undefined || request.effort.trim() === '' ? {} : { effort: request.effort.trim() },
             });
             let firstTaskSeq;
             if (request.firstTask !== undefined) {
+                // A human's invite starts a task of its own; an agent's belongs to the task it is working on.
+                const inviter = invitedBy === 'agent'
+                    ? replay(loaded.session.snapshotEvents()).members.find(member => actorChildSessionId === undefined ? member.kind === 'main-agent' : member.childSessionId === actorChildSessionId)
+                    : undefined;
+                const context = inviter === undefined ? {} : this.sendContext(loaded.session, inviter);
+                const dispatchId = randomUUID();
+                const firstTaskContext = { id: dispatchId, task: invitedBy === 'human' ? dispatchId : context.task ?? dispatchId,
+                    ...context.parent === undefined ? {} : { parent: context.parent } };
                 firstTaskSeq = loaded.session.append('room/dispatch', {
-                    id: randomUUID(), origin: invitedBy === 'human' ? 'human' : 'coordinator',
+                    origin: invitedBy === 'human' ? 'human' : 'coordinator',
                     ...invitedBy === 'human' ? {} : { replyTo: memberId(loaded.session.snapshotEvents(), coordinatorMember(replay(loaded.session.snapshotEvents()), loaded.session.snapshotEvents())) },
+                    ...request.note === undefined || request.note.trim() === '' ? {} : { note: request.note.trim().slice(0, 500) },
+                    ...firstTaskContext,
                     targetIds: [memberId(loaded.session.snapshotEvents(), replay(loaded.session.snapshotEvents()).members.find(member => member.name === request.name))],
                     targets: [request.name], text: request.firstTask,
                 }).seq;
-                loaded.session.append('room/task-added', {
-                    id: randomUUID(), member: request.name, title: taskTitle(request.firstTask), status: 'in_progress',
-                    deliveryId: `${firstTaskSeq}:${memberId(loaded.session.snapshotEvents(), replay(loaded.session.snapshotEvents()).members.find(member => member.name === request.name))}`,
-                });
             }
             await this.ctx.sessions.flush(loaded.session);
             if (request.firstTask !== undefined && firstTaskSeq !== undefined) {
                 this.engine.dispatch(loaded.session, request.name, request.firstTask, { dispatchSeq: firstTaskSeq });
             }
-            return { ok: true, value: { name: request.name, pendingFirstTask: request.firstTask !== undefined } };
+            return { ok: true, value: { name: request.name, pendingFirstTask: request.firstTask !== undefined, ...request.preset === undefined ? {} : { preset: request.preset } } };
         }
         /**
          * Invite a CLI member (the human path; see inviteMember).
@@ -544,8 +1083,10 @@ let RoomService = (() => {
                 return { ok: false, error: { code: 'member-cwd-bound' } };
             if (request.model !== undefined && member.childSessionId !== undefined)
                 return { ok: false, error: { code: 'configuration-owned-by-core' } };
-            if (request.rename === undefined && request.instructions === undefined
-                && request.cwd === undefined && request.model === undefined) {
+            if (request.effort !== undefined && member.childSessionId !== undefined)
+                return { ok: false, error: { code: 'configuration-owned-by-core' } };
+            if (request.rename === undefined && request.instructions === undefined && request.role === undefined
+                && request.cwd === undefined && request.model === undefined && request.effort === undefined) {
                 return { ok: false, error: { code: 'nothing-to-update' } };
             }
             if (request.rename !== undefined && request.rename !== request.name) {
@@ -562,18 +1103,28 @@ let RoomService = (() => {
             const instructions = typeof request.instructions === 'string' && request.instructions.trim() === ''
                 ? null
                 : request.instructions;
+            const role = typeof request.role === 'string'
+                ? (request.role.trim() === '' ? null : request.role.trim())
+                : request.role;
+            if (typeof role === 'string' && role.length > ROOM_ROLE_MAX)
+                return { ok: false, error: { code: 'role-too-long' } };
             const cwd = typeof request.cwd === 'string'
                 ? (request.cwd.trim() === '' ? null : request.cwd.trim())
                 : request.cwd;
             const model = typeof request.model === 'string'
                 ? (request.model.trim() === '' ? null : request.model.trim())
                 : request.model;
+            const effort = typeof request.effort === 'string'
+                ? (request.effort.trim() === '' ? null : request.effort.trim())
+                : request.effort;
             loaded.session.append('room/member-updated', {
                 name: request.name,
                 ...request.rename === undefined ? {} : { rename: request.rename },
                 ...instructions === undefined ? {} : { instructions },
+                ...role === undefined ? {} : { role },
                 ...cwd === undefined ? {} : { cwd },
                 ...model === undefined ? {} : { model },
+                ...effort === undefined ? {} : { effort },
             });
             await this.ctx.sessions.flush(loaded.session);
             return { ok: true, value: { name: request.name } };
@@ -602,7 +1153,7 @@ let RoomService = (() => {
                 return { ok: false, error: { code: 'coordinator-not-ready', message: 'Native preparation is unavailable in this family core' } };
             try {
                 const childSessionId = await family.prepareMember(request.sessionId, member.provider, member.childSessionId ?? memberId(loaded.session.snapshotEvents(), member), {
-                    ...member.cwd === undefined ? {} : { cwd: member.cwd }, ...member.model === undefined ? {} : { model: member.model },
+                    ...member.cwd === undefined ? {} : { cwd: member.cwd }, ...member.model === undefined ? {} : { model: member.model }, ...member.effort === undefined ? {} : { effort: member.effort },
                 });
                 loaded.session.append('room/member-updated', { name: member.name, childSessionId: SessionId(childSessionId) });
                 await this.ctx.sessions.flush(loaded.session);
@@ -627,7 +1178,7 @@ let RoomService = (() => {
             loaded.session.append('room/delivery-state', { id: delivery.id, dispatchSeq: delivery.dispatchSeq, memberId: delivery.memberId, state: request.outcome, text: request.evidence.trim() });
             const run = loaded.state.runs.find(run => run.runId === delivery.id);
             if (run !== undefined)
-                loaded.session.append('room/run-state', { member: run.member, runId: delivery.id, startedAt: run.startedAt, state: request.outcome });
+                loaded.session.append('room/run-state', { member: run.member, runId: delivery.id, startedAt: run.startedAt, state: request.outcome, ...this.terminalRunStateFields(loaded.session, loaded.state, run.member) });
             await this.ctx.sessions.flush(loaded.session);
             await this.engine.recover(loaded.session);
             return { ok: true };
@@ -646,6 +1197,10 @@ let RoomService = (() => {
                 const previous = coordinatorMember(loaded.state, events);
                 if (candidate === undefined || previous === undefined)
                     return { ok: false, error: { code: 'member-not-found' } };
+                // A native member answers inside this host already; making it the
+                // external coordinator would need the CLI coordination contract it does not speak.
+                if (candidate.kind === 'native')
+                    return { ok: false, error: { code: 'coordinator-not-ready', message: 'A native DSH member cannot coordinate yet; promote the room\'s own dsh or a CLI member' } };
                 if ((loaded.state.coordinator?.revision ?? 0) !== request.expectedRevision)
                     return { ok: false, error: { code: 'coordinator-conflict' } };
                 const agent = this.ctx.agents.get(request.sessionId);
@@ -688,15 +1243,7 @@ let RoomService = (() => {
                         return { ok: false, error: { code: 'coordinator-not-ready', message: 'Member configuration has not converged or is locked' } };
                     }
                 }
-                const handoff = [
-                    `Coordinator handoff from ${previous.name} to ${candidate.name}.`,
-                    `Room session: ${request.sessionId}. Earlier native conversations remain available by their session IDs.`,
-                    loaded.state.goal === undefined ? '' : `Goal: ${loaded.state.goal}`,
-                    loaded.state.plan === undefined ? '' : `Formal goal ${loaded.state.plan.id}, revision ${loaded.state.plan.revision}: ${loaded.state.plan.objective} (${loaded.state.plan.status}). Read room_read for attempts, evidence, dependencies and budget; preserve the current pause state.`,
-                    ...loaded.state.tasks.filter(task => !['done', 'cancelled'].includes(task.status)).map(task => `Open task ${task.id}: ${task.member}: ${task.title} (${task.status})`),
-                    ...events.filter(event => event.type === 'room/speech' || event.type === 'room/dispatch').slice(-12).map(event => event.type === 'room/speech' ? `${event.data.member}: ${event.data.text.slice(0, 1500)}`
-                        : event.type === 'room/dispatch' ? `To ${event.data.targets.join(', ')}: ${event.data.text.slice(0, 1500)}` : ''),
-                ].filter(Boolean).join('\n').slice(0, 16000);
+                const handoff = handoffText(events, loaded.state, request.sessionId, previous.name, candidate.name);
                 const value = { version: 1, memberId: request.memberId, previousMemberId: memberId(events, previous), revision: request.expectedRevision + 1, handoff };
                 loaded.session.append('room/coordinator', value);
                 await this.ctx.sessions.flush(loaded.session);
@@ -710,10 +1257,14 @@ let RoomService = (() => {
             }
         }
         /**
-         * Remove a member from the roster. An in-flight run is NOT interrupted
-         * here — cancel() first when the member is running.
+         * Remove a member and settle everything that depended on it, so the
+         * confirmation's promises hold: a running round is stopped first (the same
+         * cancel the stop button uses), queued messages to it are cancelled, every
+         * member waiting for one of its reports is told it will not come, and only
+         * then does it leave the roster. Its own session and history stay;
+         * {@link restoreMember} brings it back onto them.
          * @param request - room session, member name.
-         * @returns the removal receipt, or a rejection.
+         * @returns what the removal did, or a rejection.
          */
         async removeMember(request) {
             const loaded = await this.ensureLive(request.sessionId);
@@ -721,16 +1272,71 @@ let RoomService = (() => {
                 return { ok: false, error: loaded.error };
             if (this.handoffs.has(request.sessionId))
                 return { ok: false, error: { code: 'coordinator-busy' } };
-            if (!loaded.state.members.some(member => member.name === request.name)) {
+            const member = loaded.state.members.find(entry => entry.name === request.name);
+            if (member === undefined)
                 return { ok: false, error: { code: 'member-not-found' } };
-            }
             if (coordinatorMember(loaded.state, loaded.session.snapshotEvents())?.name === request.name)
                 return { ok: false, error: { code: 'active-coordinator' } };
-            if (loaded.state.members.find(member => member.name === request.name)?.kind === 'main-agent')
+            if (member.kind === 'main-agent')
                 return { ok: false, error: { code: 'main-member' } };
-            loaded.session.append('room/member-removed', { name: request.name });
+            const stopped = loaded.state.runs.some(run => run.member === request.name && run.state === 'running')
+                && (await this.cancel({ sessionId: request.sessionId, name: request.name })).ok;
+            const session = loaded.session;
+            const events = session.snapshotEvents();
+            const id = memberId(events, member);
+            const queued = replay(events).deliveries?.filter(row => row.memberId === id && row.status === 'queued') ?? [];
+            for (const row of queued) {
+                session.append('room/delivery-state', { id: row.id, dispatchSeq: row.dispatchSeq, memberId: id, state: 'cancelled', error: `${request.name} 已被移除` });
+            }
+            session.append('room/member-removed', { name: request.name });
+            await this.ctx.sessions.flush(session);
+            // Tell whoever waits on a cancelled delivery, now that the roster no
+            // longer holds the member (the report reads its last known name).
+            const before = session.snapshotEvents().filter(event => event.type === 'room/dispatch').length;
+            for (const row of queued) {
+                await this.engine.reportOutcome(session, row.dispatchSeq, row.id, id, 'cancelled', `${request.name} 已被移除，这条没有执行。`);
+            }
+            const reports = session.snapshotEvents().filter(event => event.type === 'room/dispatch').slice(before);
+            const notified = [...new Set(reports.flatMap(event => event.type === 'room/dispatch' ? event.data.targets : []))];
+            return { ok: true, value: { name: request.name, stopped, cancelledDeliveries: queued.length, notified } };
+        }
+        /**
+         * Undo a removal: the member rejoins under its old identity, provider,
+         * role, instructions and native session, so its memory carries on. Work
+         * the removal cancelled stays cancelled. Rejected when the name was taken
+         * in between or the member was never removed.
+         * @param request - room session, the removed member's name.
+         * @returns the restored name, or a rejection.
+         */
+        async restoreMember(request) {
+            const loaded = await this.ensureLive(request.sessionId);
+            if (!loaded.ok)
+                return { ok: false, error: loaded.error };
+            if (loaded.state.members.some(entry => entry.name === request.name))
+                return { ok: false, error: { code: 'duplicate-name' } };
+            const events = loaded.session.snapshotEvents();
+            const removal = events.findLast(event => event.type === 'room/member-removed' && event.data.name === request.name);
+            if (removal === undefined)
+                return { ok: false, error: { code: 'member-not-found' } };
+            const member = replay(events.filter(event => event.seq < removal.seq)).members.find(entry => entry.name === request.name);
+            if (member === undefined)
+                return { ok: false, error: { code: 'member-not-found' } };
+            loaded.session.append('room/member-added', {
+                id: memberId(events, member),
+                name: member.name,
+                kind: member.kind,
+                invitedBy: member.invitedBy,
+                ...member.provider === undefined ? {} : { provider: member.provider },
+                ...member.instructions === undefined ? {} : { instructions: member.instructions },
+                ...member.role === undefined ? {} : { role: member.role },
+                ...member.preset === undefined ? {} : { preset: member.preset },
+                ...member.cwd === undefined ? {} : { cwd: member.cwd },
+                ...member.model === undefined ? {} : { model: member.model },
+                ...member.effort === undefined ? {} : { effort: member.effort },
+                ...member.childSessionId === undefined ? {} : { childSessionId: member.childSessionId },
+            });
             await this.ctx.sessions.flush(loaded.session);
-            return { ok: true, value: { name: request.name } };
+            return { ok: true, value: { name: member.name } };
         }
         /**
          * Post a human @-message into the room: leading `@name` tokens address
@@ -797,73 +1403,111 @@ let RoomService = (() => {
             }
             // Leading tokens are stripped from the dispatched text; a picked mid-
             // sentence mention stays — the sentence is dispatched verbatim.
-            const text = parsed.targets.length > 0 ? parsed.text : request.text.trim();
+            const said = parsed.targets.length > 0 ? parsed.text : request.text.trim();
+            // 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;
+            // The hint rides the member's prompt only; the journal keeps the human's words.
+            const prompt = outside.length === 0 ? said : [
+                said,
+                '',
+                `（人点名了房间外的会话：${outside.map(match => `「${match[1].replace(/\\(.)/gu, '$1')}」`).join('、')}。用 room_help 去问：session 参数原样传那个 @[…](dsh-session:…) 引用；标签是「成员（房间）」时会交给那个成员。不要转给别的成员代问。）`,
+            ].join('\n');
             if (text === '')
                 return { ok: false, error: { code: 'empty-text' } };
             const roster = new Set(loaded.state.members.map(member => member.name));
             const unknown = targets.filter(target => !roster.has(target));
             if (unknown.length > 0)
                 return { ok: false, error: { code: 'unknown-targets', names: unknown } };
-            loaded.session.append('user/message', createUserMessage({
+            const human = createUserMessage({
                 content: [{ type: 'text', text: request.text.trim() }],
                 source: { kind: 'user' },
-            }), { surfaceOp: 'append' });
+            });
+            loaded.session.append('user/message', human, { surfaceOp: 'append' });
+            const filed = await this.fileHumanMessage(loaded.session, human.id, request.text.trim(), request.task ?? this.consumeTaskHint(request.sessionId));
+            this.moveOnFromLostRounds(loaded.session, targets);
             const dispatch = loaded.session.append('room/dispatch', {
-                id: request.requestId ?? randomUUID(), requestSignature, targets, text, origin: 'human',
+                id: request.requestId ?? randomUUID(), requestSignature, targets, text, origin: 'human', task: filed.task,
                 targetIds: targets.map(name => memberId(loaded.session.snapshotEvents(), loaded.state.members.find(member => member.name === name))),
             });
-            for (const target of targets) {
-                loaded.session.append('room/task-added', {
-                    id: randomUUID(), member: target, title: taskTitle(text), status: 'in_progress',
-                    deliveryId: `${dispatch.seq}:${memberId(loaded.session.snapshotEvents(), loaded.state.members.find(member => member.name === target))}`,
-                });
-            }
             await this.ctx.sessions.flush(loaded.session);
             for (const target of targets) {
-                this.engine.dispatch(loaded.session, target, text, { dispatchSeq: dispatch.seq });
+                this.engine.dispatch(loaded.session, target, prompt, { dispatchSeq: dispatch.seq });
             }
             return { ok: true, value: { parsed: { targets, text }, seq: dispatch.seq } };
         }
         /**
-         * Dispatch one message to one member (host-only — the `room_message` tool's
-         * path; the model-facing equivalent of the human's `@member text`). Same
-         * dispatch internals as postMessage minus the user/message bubble: the
-         * caller is the room's own main agent, so the text must NOT wear the human
-         * bubble (source kind 'user' would misattribute it). The dispatch record
-         * and the auto-opened in_progress task journal as usual.
-         * @param request - room session, addressee, text.
-         * @returns the dispatch receipt, or a rejection.
+         * 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
+         * coordinator's sends journal as `coordinator` dispatches, everyone else's
+         * as `member` ones. A `task` (default) has the recipient's final reply
+         * reported back to the sender; a `notify` is FYI. The room's settings may
+         * hold the message for the human instead (see messaging.ts).
+         * @param request - room session, addressee, text, kind, optional reply reference.
+         * @param actorChildSessionId - the authenticated CLI sender; absent = the room's own agent.
+         * @returns the delivery receipt (with its `m<seq>` id) or the hold, or a rejection.
          */
         async messageMember(request, actorChildSessionId) {
+            const routed = actorChildSessionId === undefined ? this.nativeRoute(request.sessionId) : undefined;
+            if (routed !== undefined)
+                return this.messageMember({ ...request, sessionId: routed.roomId }, routed.actor);
             // Messaging PROMOTES too (the room_message tool's gate): the main agent
             // answering "把 kimi 拉进来问一下…" promotes its own session, then the
             // roster check runs against the promoted state.
             const loaded = await this.ensureRoom(request.sessionId);
             if (!loaded.ok)
                 return { ok: false, error: loaded.error };
-            if (!this.isCurrentCoordinator(loaded.session, actorChildSessionId))
-                return { ok: false, error: { code: 'not-coordinator' } };
             if (this.handoffs.has(request.sessionId))
                 return { ok: false, error: { code: 'coordinator-busy' } };
-            if (!loaded.state.members.some(member => member.name === request.member)) {
+            const events = loaded.session.snapshotEvents();
+            const sender = loaded.state.members.find(member => actorChildSessionId === undefined ? member.kind === 'main-agent' : member.childSessionId === actorChildSessionId);
+            if (sender === undefined)
+                return { ok: false, error: { code: 'member-not-found' } };
+            const target = loaded.state.members.find(member => member.name === request.member || (member.childSessionId !== undefined && member.childSessionId === request.member));
+            if (target === undefined)
                 return { ok: false, error: { code: 'member-not-found' } };
-            }
             const text = request.text.trim();
             if (text === '')
                 return { ok: false, error: { code: 'empty-text' } };
-            const coordinator = coordinatorMember(loaded.state, loaded.session.snapshotEvents());
-            const target = loaded.state.members.find(member => member.name === request.member);
-            const dispatch = loaded.session.append('room/dispatch', {
-                id: randomUUID(), targets: [request.member], targetIds: [memberId(loaded.session.snapshotEvents(), target)], text, origin: 'coordinator',
-                ...coordinator === undefined || coordinator.name === request.member ? {} : { replyTo: memberId(loaded.session.snapshotEvents(), coordinator) },
-            });
-            loaded.session.append('room/task-added', {
-                id: randomUUID(), member: request.member, title: taskTitle(text), status: 'in_progress',
-                deliveryId: `${dispatch.seq}:${memberId(loaded.session.snapshotEvents(), target)}`,
+            if (target.name === sender.name)
+                return { ok: false, error: { code: 'self-message' } };
+            const senderId = memberId(events, sender);
+            const kind = request.kind ?? 'task';
+            const inReplyTo = parseMessageRef(request.inReplyTo);
+            const context = this.sendContext(loaded.session, sender);
+            let task = context.task;
+            if (request.task !== undefined && request.task.trim() !== '') {
+                const ref = resolveTaskRef(loaded.state.jobs ?? [], request.task);
+                if (ref === undefined)
+                    return { ok: false, error: { code: 'unknown-task' } };
+                // The coordinator's call re-files the human message its turn answers.
+                if (context.trigger !== undefined) {
+                    task = ref === 'new' ? context.trigger : ref;
+                    loaded.session.append('room/task-link', { message: context.trigger, task, by: 'coordinator' });
+                }
+                else {
+                    task = ref === 'new' ? SELF_TASK : ref;
+                }
+            }
+            const sent = sendOrHold(loaded.session, {
+                to: target, text, fromName: sender.name,
+                intent: {
+                    origin: this.isCurrentCoordinator(loaded.session, actorChildSessionId) ? 'coordinator' : 'member',
+                    from: senderId, kind, hop: workingHop(events, loaded.state, sender) + 1,
+                    ...kind === 'task' ? { replyTo: senderId } : {},
+                    ...inReplyTo === undefined ? {} : { inReplyTo },
+                    ...request.note === undefined || request.note.trim() === '' ? {} : { note: request.note.trim().slice(0, 500) },
+                    ...task === undefined ? {} : { task },
+                    ...context.parent === undefined ? {} : { parent: context.parent },
+                },
             });
             await this.ctx.sessions.flush(loaded.session);
-            this.engine.dispatch(loaded.session, request.member, text, { dispatchSeq: dispatch.seq });
-            return { ok: true, value: { member: request.member } };
+            if (!sent.delivered)
+                return { ok: true, value: { member: target.name, held: sent.reason } };
+            this.engine.dispatch(loaded.session, target.name, text, { dispatchSeq: sent.seq });
+            return { ok: true, value: { member: target.name, messageId: messageId(sent.seq) } };
         }
         /** Host-authenticated actor; model tool arguments never provide the room or sender. */
         isCurrentCoordinator(session, actorChildSessionId) {
@@ -871,15 +1515,358 @@ let RoomService = (() => {
             const coordinator = coordinatorMember(replay(events), events);
             return actorChildSessionId === undefined ? coordinator?.kind === 'main-agent' : coordinator?.childSessionId === actorChildSessionId;
         }
+        // ── Cross-session help (help.ts) ──────────────────────────────────────────
+        equipped = new WeakSet();
+        /** Register the helper tools on one helper agent (agent-local: they unwind with it). */
+        equipHelper(agent) {
+            if (this.equipped.has(agent))
+                return;
+            const tools = agent.ctx.get('tools');
+            if (tools === undefined)
+                return;
+            this.equipped.add(agent);
+            for (const def of helperTools(this)) {
+                try {
+                    tools.register(def);
+                }
+                catch (error) {
+                    this.ctx.logger.warn(`room: helper tool on "${agent.session.id}" was refused: ${String(error)}`);
+                }
+            }
+        }
+        /** A room's display title (its latest `session/title`), else its id. */
+        roomTitle(session) {
+            const titled = session.snapshotEvents().findLast(event => event.type === 'session/title');
+            return typeof titled?.data?.title === 'string' && titled.data.title !== '' ? titled.data.title : String(session.id);
+        }
+        /**
+         * Resolve the session a member names: an `@[…](dsh-session:…)` mention, a
+         * session id, or a title (through the host's session-reference discovery).
+         */
+        async resolveHelpTarget(caller, name) {
+            const resolver = this.ctx.get('sessionReferenceResolver');
+            if (resolver?.listCandidates === undefined)
+                return { error: 'This host cannot look sessions up; room_help is unavailable.' };
+            const mentioned = mentionedSessions(name)[0];
+            const query = (mentioned ?? name.replace(/^@/u, '')).trim();
+            let candidates = await resolver.listCandidates(caller, query, 8);
+            // 「成员（房间）」 typed as text: look the room up by its own title.
+            const inRoom = mentioned === undefined ? /^(.+)（(.+)）$/u.exec(query) : null;
+            if (candidates.length === 0 && inRoom !== null)
+                candidates = await resolver.listCandidates(caller, inRoom[2], 8);
+            const titleOf = (entry) => entry.displayTitle ?? entry.label;
+            const exact = candidates.find(entry => entry.sessionId === query) ?? candidates.find(entry => titleOf(entry) === query)
+                ?? (inRoom === null ? undefined : candidates.find(entry => titleOf(entry) === inRoom[2]));
+            const picked = exact ?? (candidates.length === 1 ? candidates[0] : undefined);
+            if (picked !== undefined)
+                return { sessionId: picked.sessionId, title: titleOf(picked) };
+            if (candidates.length === 0)
+                return { error: `No session matches "${name}". Ask the human to @ the session in the room.` };
+            return { error: `"${name}" matches several sessions: ${candidates.map(entry => `"${titleOf(entry)}" (${entry.sessionId})`).join(', ')}. Retry with the exact title or id.` };
+        }
+        /**
+         * A member asks another session for help, or writes again on a thread
+         * (the `room_help` tool). The first ask of a session the human never
+         * @-mentioned in this room waits for the human's go-ahead.
+         * @param request - the calling session, the target session (new thread) or help id (existing), the text.
+         * @param caller - the calling agent.
+         * @returns the tool's text result.
+         */
+        async askHelp(request, caller, actorChildSessionId) {
+            const text = request.text.trim();
+            if (text === '')
+                return 'The help text must be non-blank.';
+            // The asker: a CLI member (authenticated by the bridge), a native member
+            // (its own session routes to the room), else the room's own agent.
+            const routed = actorChildSessionId === undefined ? this.nativeRoute(request.sessionId) : { roomId: SessionId(request.sessionId), actor: actorChildSessionId };
+            const roomId = routed?.roomId ?? SessionId(request.sessionId);
+            const loaded = this.ctx.sessions.get(roomId) !== undefined && isRoomLog(this.ctx.sessions.get(roomId).snapshotEvents())
+                ? await this.ensureLive(roomId)
+                : undefined;
+            if (loaded === undefined || !loaded.ok)
+                return 'room_help works from inside a room; this session is not one.';
+            const room = loaded.session;
+            const events = room.snapshotEvents();
+            const asker = loaded.state.members.find(member => routed === undefined ? member.kind === 'main-agent' : member.childSessionId === routed.actor);
+            if (asker === undefined)
+                return 'Only a member of this room can ask for help.';
+            const roomTitle = this.roomTitle(room);
+            const helps = replayHelps(events);
+            const threadId = request.help?.trim();
+            if (threadId !== undefined && threadId !== '') {
+                const help = helps.find(entry => entry.id === threadId);
+                if (help === undefined)
+                    return `No help thread "${threadId}" in this room.`;
+                room.append('room/help-message', { help: help.id, kind: 'message', text });
+                await this.ctx.sessions.flush(room);
+                if (help.target.room === true)
+                    return this.deliverToRoom(room, help, text, 'message');
+                return this.deliverHelp(room, help, messagePrompt(help, roomTitle, text), 'message', text);
+            }
+            if (request.session === undefined || request.session.trim() === '')
+                return 'Name the session to ask: its title, its id, or the @ mention the human wrote.';
+            // Discovery ranks by the asking agent's workspace; a CLI member has no
+            // agent here, so the room's own stands in.
+            const finder = caller ?? this.ctx.agents.get(room.id);
+            if (finder === undefined)
+                return 'This room has no live agent to look sessions up with; try again in a moment.';
+            const target = await this.resolveHelpTarget(finder, request.session.trim());
+            if ('error' in target)
+                return target.error;
+            if (target.sessionId === room.id || loaded.state.members.some(member => member.childSessionId === target.sessionId)) {
+                return 'That session is this room or one of its members; use room_message instead.';
+            }
+            // The host fences archived sessions off (they are not listed, cannot be
+            // opened, and a waking delivery to their agent is refused): say so.
+            const archived = this.ctx.get('workspaceRegistry');
+            if (archived?.archivedSessionIds?.includes(target.sessionId) === true) {
+                return `"${target.title}" is archived; it cannot be asked. Tell the human to unarchive it first, or pick another session.`;
+            }
+            // A room target goes through that room's own roster: the named member
+            // (the argument, or the 「成员（房间）」 label the @ menu wrote), else its coordinator.
+            const targetRoom = (await this.isRoom({ sessionId: SessionId(target.sessionId) })) === true;
+            const named = request.member?.trim() || (targetRoom ? memberFromLabel(request.session, target.title) : undefined);
+            if (targetRoom) {
+                const other = await this.ensureLive(SessionId(target.sessionId));
+                if (!other.ok)
+                    return `Could not open the room "${target.title}".`;
+                if (named !== undefined && !other.state.members.some(member => member.name === named)) {
+                    return `The room "${target.title}" has no member "${named}"; its members are ${other.state.members.map(member => member.name).join(', ')}.`;
+                }
+            }
+            const consented = referencedSessions(events).has(target.sessionId) || helps.some(entry => entry.target.sessionId === target.sessionId);
+            if (!consented) {
+                const answers = await this.askQuestions(room, asker, [{
+                        id: 'help', header: '求助',
+                        question: `${asker.name} 想向会话「${target.title}」求助：${text.length > 80 ? `${text.slice(0, 80)}…` : text}`,
+                        options: [{ label: '允许' }, { label: '不允许' }],
+                    }], 10 * 60_000);
+                if (answers?.[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), from: memberId(events, asker), fromName: asker.name,
+                target: targetRoom ? { ...target, room: true, ...named === undefined ? {} : { member: named } } : target, text,
+            };
+            room.append('room/help', help);
+            await this.ctx.sessions.flush(room);
+            if (targetRoom)
+                return this.deliverToRoom(room, help, text, 'request');
+            return this.deliverHelp(room, help, requestPrompt(help, roomTitle), 'request', text);
+        }
+        /**
+         * Hand a help request (or a follow-up on it) to another room: its named
+         * member, else its coordinator, as a `help`-origin dispatch — held like any
+         * agent message while that room is paused — and shown on that room's
+         * timeline. The member's final reply comes back through {@link helpSettled}.
+         */
+        async deliverToRoom(room, help, text, op) {
+            const fail = async (error) => {
+                room.append('room/help-state', { help: help.id, state: 'failed', error });
+                await this.ctx.sessions.flush(room);
+                return `Could not reach "${help.target.title}": ${error}`;
+            };
+            const other = await this.ensureLive(SessionId(help.target.sessionId));
+            if (!other.ok)
+                return fail('that room is not available');
+            const events = other.session.snapshotEvents();
+            const member = help.target.member === undefined
+                ? coordinatorMember(other.state, events)
+                : other.state.members.find(entry => entry.name === help.target.member);
+            if (member === undefined)
+                return fail(help.target.member === undefined ? 'that room has no coordinator' : `that room has no member "${help.target.member}"`);
+            const origin = { id: help.id, room: room.id, roomTitle: this.roomTitle(room), from: help.fromName };
+            // 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 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 } : {} },
+            });
+            other.session.append('room/help-in', { ...origin, member: member.name, text, op, ...sent.delivered ? {} : { held: true } });
+            await this.ctx.sessions.flush(other.session);
+            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 });
+            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.`;
+        }
+        /**
+         * A help dispatch in this room settled: its final reply (or its failure)
+         * goes back to the asking room's thread.
+         * @param room - the room that was asked.
+         * @param dispatchSeq - the settled dispatch.
+         * @param outcome - the run's outcome.
+         */
+        async helpSettled(room, dispatchSeq, outcome) {
+            const source = dispatchSeq === undefined ? undefined : room.snapshotEvents().find(event => event.seq === dispatchSeq);
+            if (source?.type !== 'room/dispatch' || source.data.help === undefined)
+                return;
+            const asked = source.data.help;
+            const loaded = await this.ensureLive(SessionId(asked.room));
+            if (!loaded.ok)
+                return;
+            const thread = replayHelps(loaded.session.snapshotEvents()).find(entry => entry.id === asked.id);
+            if (thread === undefined)
+                return;
+            if (outcome.state === 'done') {
+                const text = outcome.text?.trim();
+                await this.recordHelperMessage(loaded.session, thread, { kind: 'reply', text: text === undefined || text === '' ? '（对方这一轮结束了，没有给出答复）' : text });
+                return;
+            }
+            loaded.session.append('room/help-state', { help: thread.id, state: 'failed', error: outcome.error ?? `对方这一轮${outcome.state === 'cancelled' ? '被取消了' : '没有完成'}` });
+            await this.ctx.sessions.flush(loaded.session);
+        }
+        /** Queue one help message in the helper's session (waking it when cold) and watch its turn. */
+        async deliverHelp(room, help, prompt, op, display) {
+            const fail = async (error) => {
+                room.append('room/help-state', { help: help.id, state: 'failed', error });
+                await this.ctx.sessions.flush(room);
+                return `Could not reach "${help.target.title}": ${error}`;
+            };
+            const controller = this.ctx.get('sessionController');
+            if (controller?.resolveAgent === undefined)
+                return fail('this host cannot wake other sessions');
+            let agent;
+            try {
+                const resolved = await controller.resolveAgent(SessionId(help.target.sessionId));
+                if ('error' in resolved)
+                    return await fail(resolved.error.message);
+                agent = resolved.agent;
+            }
+            catch (error) {
+                return fail(String(error));
+            }
+            this.equipHelper(agent);
+            const queued = agent.status === 'running';
+            const message = helpMessage(prompt, { help: help.id, room: room.id, roomTitle: this.roomTitle(room), from: help.fromName, op, text: display.slice(0, 4000) });
+            room.append('room/help-state', { help: help.id, state: queued ? 'queued' : 'running' });
+            await this.ctx.sessions.flush(room);
+            const mark = room.snapshotEvents().at(-1)?.seq ?? -1;
+            agent.followup(message);
+            this.watchHelp(room.id, help.id, agent, String(message.id), mark);
+            return `${queued ? `Sent to "${help.target.title}"; it is busy, so the request waits in its queue.` : `Sent to "${help.target.title}".`}`
+                + ` Help id: ${help.id}. Its reply reaches you on its own — end your turn now; do not poll.`;
+        }
+        /**
+         * After the helper's turn: a turn that never claimed the message failed the
+         * thread; one that ended without the reply or question tool hands over its
+         * last answer as the reply.
+         */
+        watchHelp(roomId, helpId, agent, messageId, mark) {
+            void (async () => {
+                await agent.whenIdle();
+                const loaded = await this.ensureLive(roomId);
+                if (!loaded.ok)
+                    return;
+                const room = loaded.session;
+                const help = replayHelps(room.snapshotEvents()).find(entry => entry.id === helpId);
+                if (help === undefined || help.state === 'failed')
+                    return;
+                const answered = room.snapshotEvents().some(event => event.seq > mark && event.type === 'room/help-message' && event.data.help === helpId && event.data.kind !== 'message');
+                if (answered)
+                    return;
+                const helperEvents = agent.session.snapshotEvents();
+                if (!claimed(helperEvents, messageId)) {
+                    room.append('room/help-state', { help: helpId, state: 'failed', error: 'the request left the helper\'s queue without being handled' });
+                    await this.ctx.sessions.flush(room);
+                    return;
+                }
+                const answer = turnAnswer(helperEvents, messageId);
+                await this.recordHelperMessage(room, help, { kind: 'reply', text: answer === '' ? '（对方这一轮结束了，没有给出答复）' : answer, fallback: true });
+            })().catch((error) => { this.ctx.logger.warn(`room: help ${helpId} watch faulted: ${String(error)}`); });
+        }
+        /** A help request reached the helper's turn: a queued thread is running now. */
+        async markHelpRunning(source) {
+            const room = this.ctx.sessions.get(SessionId(source.room));
+            if (room === undefined)
+                return;
+            const help = replayHelps(room.snapshotEvents()).find(entry => entry.id === source.help);
+            if (help === undefined || help.state === 'running')
+                return;
+            if (help.state !== 'queued' && !(help.state === 'asking' && source.op === 'message') && !(help.state === 'replied' && source.op === 'message'))
+                return;
+            room.append('room/help-state', { help: help.id, state: 'running' });
+            await this.ctx.sessions.flush(room);
+        }
+        /** Journal a helper's question or reply and hand it to the asking member. */
+        async recordHelperMessage(room, help, message) {
+            room.append('room/help-message', { help: help.id, kind: message.kind, text: message.text, ...message.handoff === undefined ? {} : { handoff: message.handoff }, ...message.fallback === undefined ? {} : { fallback: true } });
+            room.append('room/help-state', { help: help.id, state: message.kind === 'reply' ? 'replied' : 'asking' });
+            const events = room.snapshotEvents();
+            const state = replay(events);
+            const asker = state.members.find(member => memberId(events, member) === help.from) ?? coordinatorMember(state, events);
+            if (asker === undefined) {
+                await this.ctx.sessions.flush(room);
+                return;
+            }
+            const text = askerPrompt(help, message);
+            const dispatch = room.append('room/dispatch', {
+                id: randomUUID(), origin: 'report', reportFor: `help:${help.id}`, targets: [asker.name], targetIds: [memberId(events, asker)], text,
+            });
+            await this.ctx.sessions.flush(room);
+            this.engine.dispatch(room, asker.name, text, { dispatchSeq: dispatch.seq });
+        }
+        /**
+         * The helper's `room_help_reply` / `room_help_ask`: find the thread from
+         * the help requests in the helper's own log, then carry the message back.
+         * @param agent - the helper agent.
+         * @param request - thread (optional when only one), kind, text, handoff.
+         * @returns the tool's text result.
+         */
+        async helperMessage(agent, request) {
+            const received = receivedHelps(agent.session.snapshotEvents());
+            const wanted = request.help?.trim();
+            const source = wanted === undefined || wanted === '' ? received.at(-1) : received.find(entry => entry.help === wanted);
+            if (source === undefined) {
+                return received.length === 0
+                    ? 'No help request reached this session.'
+                    : `No help "${wanted}" here; the requests this session received: ${received.map(entry => `${entry.help} (from ${entry.from} in "${entry.roomTitle}")`).join(', ')}.`;
+            }
+            const text = request.text.trim();
+            if (text === '')
+                return 'The text must be non-blank.';
+            const loaded = await this.ensureLive(SessionId(source.room));
+            if (!loaded.ok)
+                return `The room "${source.roomTitle}" that asked is no longer available.`;
+            const help = replayHelps(loaded.session.snapshotEvents()).find(entry => entry.id === source.help);
+            if (help === undefined)
+                return 'That help thread is gone.';
+            const handoff = request.handoff?.trim();
+            await this.recordHelperMessage(loaded.session, help, { kind: request.kind, text, ...handoff === undefined || handoff === '' ? {} : { handoff } });
+            return request.kind === 'reply'
+                ? `Your reply reached ${help.fromName} in "${source.roomTitle}".`
+                : `Your question went to ${help.fromName} in "${source.roomTitle}"; the answer arrives as a new message. End your turn now.`;
+        }
         /** Bounded shared room context for native and external model tools; reading never wakes an agent. */
         async readRoomContext(sessionId) {
+            const routed = this.nativeRoute(sessionId);
+            if (routed !== undefined) {
+                const self = replay(this.ctx.sessions.get(routed.roomId).snapshotEvents()).members.find(member => member.childSessionId === routed.actor)?.name;
+                return JSON.stringify({ self, ...JSON.parse(await this.readRoomContext(routed.roomId)) });
+            }
             const state = await this.getState({ sessionId: SessionId(sessionId) });
+            if (!state.ok && state.error.code === 'not-a-room') {
+                // A plain session: everything an invite needs, instead of an error that
+                // sends the model guessing provider ids.
+                const offered = await this.listProviders({ sessionId: SessionId(sessionId) });
+                return JSON.stringify({
+                    room: false,
+                    note: 'This session is not a room yet. room_invite promotes it into one: no other setup is needed.',
+                    providers: offered.providers.map(entry => ({ provider: entry.provider, name: entry.displayName, ...entry.authenticated ? {} : { loggedOut: true } })),
+                    ...offered.presets === undefined ? {} : { modes: offered.presets.map(entry => ({ id: entry.id, ...entry.name === undefined ? {} : { name: entry.name } })) },
+                    ...offered.sessionPreset === undefined ? {} : { sessionMode: offered.sessionPreset },
+                });
+            }
             if (!state.ok)
                 throw new Error(`Room unavailable: ${state.error.code}`);
             const events = this.ctx.sessions.get(SessionId(sessionId))?.snapshotEvents() ?? [];
             const recent = events.filter(event => event.type === 'room/speech').slice(-12).map(event => event.type === 'room/speech' ? { member: event.data.member, text: event.data.text.slice(0, 2000) } : null);
             return JSON.stringify({ planCommands: planCommandContract(), coordinator: coordinatorMember(state.value)?.name,
-                state: { ...state.value, deliveries: state.value.deliveries?.slice(-30), tasks: state.value.tasks.slice(-100), relays: state.value.relays.slice(-30) },
+                state: { ...state.value, deliveries: state.value.deliveries?.slice(-30), jobs: state.value.jobs?.slice(0, 20), relays: state.value.relays.slice(-30) },
                 providers: await this.listProviders({}), recent });
         }
         /** Human UI and native/external tools share the same durable transition service. */
@@ -899,6 +1886,9 @@ let RoomService = (() => {
         }
         /** The actor is derived from the calling native agent or authenticated bridge. */
         async commandPlan(sessionId, command, actorChildSessionId) {
+            const routed = actorChildSessionId === undefined ? this.nativeRoute(sessionId) : undefined;
+            if (routed !== undefined)
+                return this.commandPlan(routed.roomId, command, routed.actor);
             const loaded = await this.ensureLive(SessionId(sessionId));
             if (!loaded.ok)
                 throw new Error(loaded.error.code);
@@ -914,6 +1904,151 @@ let RoomService = (() => {
             const { requests: _requests, ...view } = plan;
             return JSON.stringify(view);
         }
+        /**
+         * The mode of an external member — the host preset whose plugin tools its
+         * bridge offers (local-agent's preset tool host runs them) — with its
+         * working directory. Host method for the member channel, never a Remote.
+         * @param actor - the authenticated member run.
+         * @returns the mode, or undefined when the member has none or is not here.
+         */
+        async memberMode(actor) {
+            const loaded = await this.ensureLive(SessionId(actor.parentSessionId));
+            if (!loaded.ok)
+                return undefined;
+            const cli = loaded.state.members.filter(entry => entry.kind === 'cli' && entry.provider === actor.provider);
+            // A member's first round asks before the journal knows its child session
+            // (claude lists MCP tools at spawn): the one first start in flight for
+            // this provider is the asker. Two at once stay ambiguous — no mode.
+            const starting = this.engine.startingMembers(actor.parentSessionId);
+            const fresh = cli.filter(entry => entry.childSessionId === undefined && starting.includes(memberId(loaded.session.snapshotEvents(), entry)));
+            const member = cli.find(entry => entry.childSessionId === actor.childSessionId)
+                ?? (fresh.length === 1 ? fresh[0] : undefined);
+            if (member?.preset === undefined)
+                return undefined;
+            const cwd = member.cwd ?? loaded.session.header.cwd;
+            return { preset: member.preset, ...cwd === undefined ? {} : { cwd } };
+        }
+        /** Pending member tool approvals this process can still answer: approval id → its waiting call. */
+        approvalWaiters = new Map();
+        /** Close approvals no waiting call stands behind any more (a restart lost it). */
+        expireApprovals(session) {
+            for (const approval of replay(session.snapshotEvents()).approvals ?? []) {
+                if (!this.approvalWaiters.has(approval.id))
+                    session.append('room/approval-resolved', { id: approval.id, outcome: 'cancelled' });
+            }
+        }
+        /**
+         * A CLI member's mode tool needs the human's approval: ask in the room's
+         * conversation (a 允许 / 拒绝 line) and resolve when the human answers,
+         * the call is cancelled, or the room is gone. Host method for the member
+         * channel (local-agent's approval hook), never a Remote.
+         * @param actor - the authenticated member run.
+         * @param request - the tool, an optional reason, and the call's signal.
+         * @returns the approval outcome the tool registry expects.
+         */
+        async askMemberApproval(actor, request) {
+            const loaded = await this.ensureLive(SessionId(actor.parentSessionId));
+            if (!loaded.ok)
+                return 'unavailable';
+            const events = loaded.session.snapshotEvents();
+            const member = loaded.state.members.find(entry => entry.childSessionId === actor.childSessionId && entry.provider === actor.provider);
+            if (member === undefined)
+                return 'unavailable';
+            if (request.signal?.aborted === true)
+                return 'cancelled';
+            const id = randomUUID();
+            const session = loaded.session;
+            const answered = new Promise((resolve) => {
+                this.approvalWaiters.set(id, resolve);
+                request.signal?.addEventListener('abort', () => { resolve('cancelled'); }, { once: true });
+            });
+            session.append('room/approval', { id, member: member.name, memberId: memberId(events, member), tool: request.toolName,
+                ...request.reason === undefined || request.reason.trim() === '' ? {} : { reason: request.reason.trim().slice(0, 500) } });
+            await this.ctx.sessions.flush(session);
+            const outcome = await answered;
+            this.approvalWaiters.delete(id);
+            if (replay(session.snapshotEvents()).approvals?.some(entry => entry.id === id) === true) {
+                session.append('room/approval-resolved', { id, outcome });
+                await this.ctx.sessions.flush(session);
+            }
+            return outcome;
+        }
+        /**
+         * The human answers a member's tool approval from the room.
+         * @param request - room session, approval id, allow once or reject.
+         * @returns ok, or `approval-not-pending` when it already ended.
+         */
+        async answerApproval(request) {
+            const loaded = await this.ensureLive(request.sessionId);
+            if (!loaded.ok)
+                return { ok: false, error: loaded.error };
+            const waiter = this.approvalWaiters.get(request.id);
+            if (waiter === undefined || loaded.state.approvals?.some(entry => entry.id === request.id) !== true)
+                return { ok: false, error: { code: 'approval-not-pending' } };
+            loaded.session.append('room/approval-resolved', { id: request.id, outcome: request.outcome });
+            await this.ctx.sessions.flush(loaded.session);
+            waiter(request.outcome);
+            return { ok: true };
+        }
+        /** Pending member questions this process can still answer: question id → its waiting call. */
+        questionWaiters = new Map();
+        /** Close question cards no waiting call stands behind any more (a restart lost it). */
+        expireQuestions(session) {
+            for (const question of replay(session.snapshotEvents()).questions ?? []) {
+                if (!this.questionWaiters.has(question.id))
+                    session.append('room/question-resolved', { id: question.id, outcome: 'cancelled' });
+            }
+        }
+        /**
+         * A member asks the human questions (its bridge's `ask_user_question`):
+         * journal a pick-to-answer card in the room and wait for the answer, the
+         * timeout, or the room going away.
+         * @param session - the live room session.
+         * @param member - the asking member.
+         * @param questions - the validated questions.
+         * @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) {
+            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 });
+            await this.ctx.sessions.flush(session);
+            const answers = await answered;
+            this.questionWaiters.delete(id);
+            if (answers === undefined && replay(session.snapshotEvents()).questions?.some(entry => entry.id === id) === true) {
+                session.append('room/question-resolved', { id, outcome: 'cancelled' });
+                await this.ctx.sessions.flush(session);
+            }
+            return answers;
+        }
+        /**
+         * The human answers a member's question card from the room.
+         * @param request - room session, card id, one answer per question.
+         * @returns ok, or `question-not-pending` when it already ended.
+         */
+        async answerQuestion(request) {
+            const loaded = await this.ensureLive(request.sessionId);
+            if (!loaded.ok)
+                return { ok: false, error: loaded.error };
+            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' } };
+            // 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);
+                const custom = given?.custom?.trim();
+                return { id: question.id, selected: [...given?.selected ?? []].filter(label => typeof label === 'string'), ...custom === undefined || custom === '' ? {} : { custom } };
+            });
+            loaded.session.append('room/question-resolved', { id: request.id, outcome: 'answered', answers });
+            await this.ctx.sessions.flush(loaded.session);
+            waiter(answers);
+            return { ok: true };
+        }
         /** Shared backend for external MCP room tools. Not exposed as a browser Remote. */
         async receiveMemberCommand(actor, command) {
             try {
@@ -926,7 +2061,7 @@ let RoomService = (() => {
                 if (command === null || typeof command !== 'object' || command.arguments === null || typeof command.arguments !== 'object' || Array.isArray(command.arguments))
                     return { ok: false, error: 'Malformed room command' };
                 const args = command.arguments;
-                const allowed = { room_plan: ['command'], room_read: [], room_invite: ['provider', 'name', 'instructions', 'cwd', 'model', 'firstTask'], room_message: ['member', 'text'] };
+                const allowed = { room_plan: ['command'], room_read: [], room_invite: ['provider', 'name', 'role', 'instructions', 'cwd', 'model', 'effort', 'mode', 'firstTask', 'note'], room_message: ['member', 'text', 'kind', 'inReplyTo', 'note', 'task'], ask_user_question: ['questions'], room_help: ['session', 'member', 'help', 'text'] };
                 const keys = allowed[command.name];
                 if (keys === undefined || Object.keys(args).some(key => !keys.includes(key)))
                     return { ok: false, error: 'Unknown room command or argument; room and actor identity are host-owned' };
@@ -937,21 +2072,50 @@ let RoomService = (() => {
                     return value;
                 };
                 const optional = (key) => args[key] === undefined ? undefined : required(key);
+                if (command.name === 'ask_user_question') {
+                    const questions = parseQuestions(args.questions);
+                    if (typeof questions === 'string')
+                        return { ok: false, error: questions };
+                    const answers = await this.askQuestions(loaded.session, sender, questions, QUESTION_TIMEOUT_MS);
+                    return answers === undefined
+                        ? { ok: false, error: 'The human did not answer (the question expired or the room was stopped). Continue with your best judgement and say what you assumed.' }
+                        : { ok: true, receipt: JSON.stringify({ answers }) };
+                }
+                if (command.name === 'room_help') {
+                    const text = await this.askHelp({ sessionId: loaded.session.id, text: required('text'),
+                        ...optional('session') === undefined ? {} : { session: optional('session') },
+                        ...optional('member') === undefined ? {} : { member: optional('member') },
+                        ...optional('help') === undefined ? {} : { help: optional('help') } }, undefined, actor.childSessionId);
+                    return { ok: true, receipt: text };
+                }
                 if (command.name === 'room_read') {
                     return { ok: true, receipt: JSON.stringify({ self: sender.name, ...JSON.parse(await this.readRoomContext(loaded.session.id)) }) };
                 }
                 if (command.name === 'room_plan')
                     return { ok: true, receipt: await this.commandPlan(loaded.session.id, required('command'), actor.childSessionId) };
+                if (command.name === 'room_message') {
+                    const kind = optional('kind');
+                    if (kind !== undefined && kind !== 'task' && kind !== 'notify')
+                        return { ok: false, error: 'kind must be "task" or "notify"' };
+                    const sent = await this.messageMember({ sessionId: loaded.session.id, member: required('member'), text: required('text'),
+                        ...kind === undefined ? {} : { kind }, ...optional('inReplyTo') === undefined ? {} : { inReplyTo: optional('inReplyTo') },
+                        ...optional('note') === undefined ? {} : { note: optional('note') },
+                        ...optional('task') === undefined ? {} : { task: optional('task') } }, actor.childSessionId);
+                    return sent.ok ? { ok: true, receipt: messageReceipt(sent.value, kind ?? 'task') } : { ok: false, error: sent.error.code };
+                }
                 if (!this.isCurrentCoordinator(loaded.session, actor.childSessionId))
-                    return { ok: false, error: 'Only the current coordinator may invite members or dispatch work' };
-                const result = command.name === 'room_invite'
-                    ? await this.inviteMember({ sessionId: loaded.session.id, provider: required('provider'), name: required('name'),
-                        ...optional('instructions') === undefined ? {} : { instructions: optional('instructions') },
-                        ...optional('cwd') === undefined ? {} : { cwd: optional('cwd') },
-                        ...optional('model') === undefined ? {} : { model: optional('model') },
-                        ...optional('firstTask') === undefined ? {} : { firstTask: optional('firstTask') },
-                    }, 'agent', actor.childSessionId)
-                    : await this.messageMember({ sessionId: loaded.session.id, member: required('member'), text: required('text') }, actor.childSessionId);
+                    return { ok: false, error: 'Only the current coordinator may invite members' };
+                const result = await this.inviteMember({ sessionId: loaded.session.id, provider: required('provider'), name: required('name'),
+                    ...optional('role') === undefined ? {} : { role: optional('role') },
+                    ...optional('instructions') === undefined ? {} : { instructions: optional('instructions') },
+                    ...optional('cwd') === undefined ? {} : { cwd: optional('cwd') },
+                    ...optional('model') === undefined ? {} : { model: optional('model') },
+                    ...optional('effort') === undefined ? {} : { effort: optional('effort') },
+                    ...optional('firstTask') === undefined ? {} : { firstTask: optional('firstTask') },
+                    ...optional('note') === undefined ? {} : { note: optional('note') },
+                    // Omitted keeps the room's own mode; "none" asks for none.
+                    ...optional('mode') === undefined ? { inheritPreset: true } : optional('mode') === 'none' ? {} : { preset: optional('mode') },
+                }, 'agent', actor.childSessionId);
                 return result.ok ? { ok: true, receipt: JSON.stringify(result.value) } : { ok: false, error: result.error.code };
             }
             catch (error) {
@@ -959,20 +2123,18 @@ let RoomService = (() => {
             }
         }
         /**
-         * The notification gate entry, verbatim-frozen contract for the local-agent
-         * family bridge (`ctx.get('room')` + duck-typed call). The call crosses an
-         * untyped package boundary, so the message shape is validated at runtime:
-         * a malformed message throws (the bridge treats a rejection as "room does
+         * The bridge's `member_message` entry (contract shared with the local-agent
+         * family: `ctx.get('room')` + duck-typed call). The call crosses an untyped
+         * package boundary, so the message shape is validated at runtime: a
+         * malformed message throws (the bridge treats a rejection as "room does
          * not claim this" and delivers directly) instead of poisoning the journal.
-         * `from`/`to` arrive as roster names OR member child session ids (the
-         * bridge cannot speak names for the sender — only room owns the roster);
-         * both are normalized to roster names when resolvable, so the pending card
-         * and the delivery text (`{from} 给你的通知: …`) read as names. Phase 1's
-         * gate is ALWAYS human confirmation: the relay is journaled pending and
-         * the sender receives 'pending-confirm' (never 'sent' — the bridge keeps
-         * the member's conclusion honest). A non-room parent session throws.
-         * @param request - sender, recipient, content, the shared parent session, provenance.
-         * @returns the gate receipt.
+         * A roster sender (resolved by child session id + provider, never
+         * self-reported) goes through {@link messageMember}: delivered at once or
+         * held by the room's settings. The receipt tells the model what happened
+         * (`sent #m12 …` / `pending-confirm …`). A sender the roster does not know
+         * keeps the legacy pending relay.
+         * @param request - sender, recipient, content, the shared parent session, provenance, kind.
+         * @returns the receipt quoted back to the sending model.
          */
         async receiveMemberMessage(request) {
             if (typeof request?.from !== 'string' || typeof request.to !== 'string'
@@ -983,14 +2145,15 @@ let RoomService = (() => {
             if (!loaded.ok)
                 throw new Error(`room: not a room session (${loaded.error.code})`);
             const sender = loaded.state.members.find(member => member.childSessionId === request.from && member.provider === request.provenance?.provider);
-            if (sender !== undefined && this.isCurrentCoordinator(loaded.session, request.from)) {
-                const target = loaded.state.members.find(member => member.name === request.to || member.childSessionId === request.to);
-                if (target === undefined)
-                    throw new Error('Unknown room member');
-                const result = await this.messageMember({ sessionId: loaded.session.id, member: target.name, text: request.content }, request.from);
+            if (sender !== undefined) {
+                const kind = request.kind === 'notify' ? 'notify' : 'task';
+                const result = await this.messageMember({ sessionId: loaded.session.id, member: request.to, text: request.content, kind,
+                    ...typeof request.inReplyTo === 'string' ? { inReplyTo: request.inReplyTo } : {},
+                    ...typeof request.note === 'string' ? { note: request.note } : {},
+                    ...typeof request.task === 'string' ? { task: request.task } : {} }, request.from);
                 if (!result.ok)
                     throw new Error(result.error.code);
-                return 'sent';
+                return messageReceipt(result.value, kind);
             }
             const resolveName = (endpoint) => {
                 const byName = loaded.state.members.find(member => member.name === endpoint);
@@ -1028,6 +2191,11 @@ let RoomService = (() => {
             if (!loaded.state.members.some(member => member.name === relay.to)) {
                 return { ok: false, error: { code: 'member-not-found' } };
             }
+            if (relay.intent !== undefined) {
+                this.release(loaded.session, relay, true);
+                await this.ctx.sessions.flush(loaded.session);
+                return { ok: true, value: { relayId: relay.id } };
+            }
             loaded.session.append('room/relay-resolved', { id: relay.id, state: 'confirmed' });
             await this.ctx.sessions.flush(loaded.session);
             this.engine.dispatch(loaded.session, relay.to, `${relay.from} 给你的通知: ${relay.content}`, {
@@ -1036,109 +2204,168 @@ let RoomService = (() => {
             return { ok: true, value: { relayId: relay.id } };
         }
         /**
-         * Dismiss a pending relay: the notification never reaches anyone.
-         * @param request - room session, relay id.
-         * @returns the resolution receipt, or a rejection.
+         * Deliver a held message as the dispatch it would have been. `force`
+         * (the human's confirm) skips the hold rules; otherwise (resuming a paused
+         * room) they are re-checked, so a message may be held again for another
+         * reason — the old hold is then superseded (dismissed) by the new one.
+         * The caller flushes.
          */
-        async dismissRelay(request) {
+        release(session, relay, force) {
+            const intent = releaseIntent(relay);
+            const target = replay(session.snapshotEvents()).members.find(member => member.name === relay.to);
+            if (intent === undefined || target === undefined)
+                return;
+            const sent = sendOrHold(session, { to: target, text: relay.content, fromName: relay.from, intent }, force);
+            session.append('room/relay-resolved', { id: relay.id, state: sent.delivered ? 'sent' : 'dismissed' });
+            if (sent.delivered)
+                this.engine.dispatch(session, target.name, relay.content, { dispatchSeq: sent.seq });
+        }
+        /**
+         * Hand a member the reports the gate holds for it now (the room's
+         * 「现在交给」 button).
+         * @param request - room session, member name.
+         * @returns whether anything was held.
+         */
+        async releaseReports(request) {
             const loaded = await this.ensureLive(request.sessionId);
             if (!loaded.ok)
                 return { ok: false, error: loaded.error };
-            const relay = loaded.state.relays.find(entry => entry.id === request.relayId);
-            if (relay === undefined)
-                return { ok: false, error: { code: 'relay-not-found' } };
-            if (relay.state !== 'pending')
-                return { ok: false, error: { code: 'relay-not-pending' } };
-            loaded.session.append('room/relay-resolved', { id: relay.id, state: 'dismissed' });
-            await this.ctx.sessions.flush(loaded.session);
-            return { ok: true, value: { relayId: relay.id } };
+            const member = loaded.state.members.find(entry => entry.name === request.name);
+            if (member === undefined)
+                return { ok: false, error: { code: 'member-not-found' } };
+            const released = await this.engine.releaseHeld(loaded.session, memberId(loaded.session.snapshotEvents(), member), 'manual');
+            return { ok: true, value: { released } };
         }
         /**
-         * Add a task to a member's board lane (the human's management entry; @-
-         * dispatches auto-open in_progress tasks, this opens a pending one).
-         * `blockedBy` names the member the task waits on (display only — it never
-         * dispatches anything); it must resolve against the roster.
-         * @param request - room session, member, title, optional blockedBy.
-         * @returns the new task's id, or a rejection.
+         * Change the room's collaboration settings (any subset). Resuming a paused
+         * room releases everything the pause held, in order.
+         * @param request - room session and the fields to change.
+         * @returns the settings after the change, or a rejection.
          */
-        async addTask(request) {
+        async setSettings(request) {
             const loaded = await this.ensureLive(request.sessionId);
             if (!loaded.ok)
                 return { ok: false, error: loaded.error };
-            if (!loaded.state.members.some(member => member.name === request.member)) {
-                return { ok: false, error: { code: 'member-not-found' } };
+            if (request.hopLimit !== undefined && (!Number.isInteger(request.hopLimit) || request.hopLimit < 2 || request.hopLimit > 50)) {
+                return { ok: false, error: { code: 'invalid-settings' } };
             }
-            if (request.title.trim() === '')
-                return { ok: false, error: { code: 'empty-text' } };
-            if (request.blockedBy !== undefined
-                && !loaded.state.members.some(member => member.name === request.blockedBy)) {
-                return { ok: false, error: { code: 'member-not-found' } };
+            if (request.memberMessages !== undefined && request.memberMessages !== 'free' && request.memberMessages !== 'confirm') {
+                return { ok: false, error: { code: 'invalid-settings' } };
+            }
+            if (request.reportTiming !== undefined && request.reportTiming !== 'judge' && request.reportTiming !== 'each') {
+                return { ok: false, error: { code: 'invalid-settings' } };
+            }
+            if (request.autoTaskFiling !== undefined && typeof request.autoTaskFiling !== 'boolean')
+                return { ok: false, error: { code: 'invalid-settings' } };
+            if (request.reportThreshold !== undefined && (typeof request.reportThreshold !== 'number' || !(request.reportThreshold >= 0.1 && request.reportThreshold <= 0.9))) {
+                return { ok: false, error: { code: 'invalid-settings' } };
+            }
+            if (request.reportWaitMinutes !== undefined && (!Number.isInteger(request.reportWaitMinutes) || request.reportWaitMinutes < 1 || request.reportWaitMinutes > 30)) {
+                return { ok: false, error: { code: 'invalid-settings' } };
+            }
+            if (request.helpReminderMinutes !== undefined && (!Number.isInteger(request.helpReminderMinutes) || request.helpReminderMinutes < 10 || request.helpReminderMinutes > 120)) {
+                return { ok: false, error: { code: 'invalid-settings' } };
+            }
+            const change = {
+                ...request.helpReminderMinutes === undefined ? {} : { helpReminderMinutes: request.helpReminderMinutes },
+                ...request.memberMessages === undefined ? {} : { memberMessages: request.memberMessages },
+                ...request.hopLimit === undefined ? {} : { hopLimit: request.hopLimit },
+                ...request.paused === undefined ? {} : { paused: request.paused },
+                ...request.reportTiming === undefined ? {} : { reportTiming: request.reportTiming },
+                ...request.autoTaskFiling === undefined ? {} : { autoTaskFiling: request.autoTaskFiling },
+                ...request.reportThreshold === undefined ? {} : { reportThreshold: Math.round(request.reportThreshold * 100) / 100 },
+                ...request.reportWaitMinutes === undefined ? {} : { reportWaitMinutes: request.reportWaitMinutes },
+            };
+            if (Object.keys(change).length === 0)
+                return { ok: false, error: { code: 'nothing-to-update' } };
+            const wasPaused = loaded.state.settings?.paused === true;
+            loaded.session.append('room/settings', change);
+            if (wasPaused && request.paused === false) {
+                for (const relay of loaded.state.relays) {
+                    if (relay.state === 'pending' && relay.reason === 'paused')
+                        this.release(loaded.session, relay, false);
+                }
             }
-            const id = randomUUID();
-            loaded.session.append('room/task-added', {
-                id, member: request.member, title: request.title.trim(), status: 'pending',
-                ...request.blockedBy === undefined ? {} : { blockedBy: request.blockedBy },
-            });
             await this.ctx.sessions.flush(loaded.session);
-            return { ok: true, value: { id } };
+            return { ok: true, value: replay(loaded.session.snapshotEvents()).settings ?? DEFAULT_ROOM_SETTINGS };
         }
         /**
-         * Close an open task (done by default, or cancelled). A failed task is
-         * still open for closing — that is the human's dismiss path after a
-         * failed run (the board's [关闭] passes 'cancelled').
-         * @param request - room session, task id, optional closing status.
-         * @returns the closed task's id, or a rejection.
+         * Keep an outside session on the member list (「加入房间成员」): only a
+         * shortcut for asking it — it stays in its own session, asks still go
+         * through room_help, and its usage stays its own.
+         * @param request - room session, the outside session and its title.
+         * @returns ok, or a rejection.
          */
-        async closeTask(request) {
+        async linkSession(request) {
             const loaded = await this.ensureLive(request.sessionId);
             if (!loaded.ok)
                 return { ok: false, error: loaded.error };
-            const task = loaded.state.tasks.find(entry => entry.id === request.taskId);
-            if (task === undefined)
-                return { ok: false, error: { code: 'task-not-found' } };
-            if (task.status === 'done' || task.status === 'cancelled') {
-                return { ok: false, error: { code: 'task-closed' } };
+            const title = request.title?.trim();
+            if (request.target === request.sessionId || title === undefined || title === '' || loaded.state.members.some(member => member.childSessionId === request.target)) {
+                return { ok: false, error: { code: 'invalid-settings' } };
             }
-            loaded.session.append('room/task-updated', { id: task.id, status: request.status ?? 'done' });
+            if (loaded.state.linked?.some(entry => entry.sessionId === request.target) === true)
+                return { ok: true };
+            loaded.session.append('room/help-link', { sessionId: request.target, title });
             await this.ctx.sessions.flush(loaded.session);
-            return { ok: true, value: { id: task.id } };
+            return { ok: true };
         }
         /**
-         * Edit an open task's title and/or blockedBy (the `room_task` tool's update
-         * action; journaled as `room/task-edited`, status changes stay on
-         * closeTask). Host method only — the capsule UI edits nothing but the goal.
-         * `blockedBy: null` clears the wait; a string must resolve against the
-         * roster. A closed task takes no edits.
-         * @param request - room session, task id, and at least one edited field.
-         * @returns the edited task's id, or a rejection.
+         * Take an outside session off the member list (its own session is untouched).
+         * @param request - room session, the outside session.
+         * @returns ok, or `member-not-found` when it was not on the list.
          */
-        async updateTask(request) {
+        async unlinkSession(request) {
             const loaded = await this.ensureLive(request.sessionId);
             if (!loaded.ok)
                 return { ok: false, error: loaded.error };
-            const task = loaded.state.tasks.find(entry => entry.id === request.taskId);
-            if (task === undefined)
-                return { ok: false, error: { code: 'task-not-found' } };
-            if (task.status === 'done' || task.status === 'cancelled') {
-                return { ok: false, error: { code: 'task-closed' } };
-            }
-            if (request.title === undefined && request.blockedBy === undefined) {
-                return { ok: false, error: { code: 'nothing-to-update' } };
-            }
-            if (request.title !== undefined && request.title.trim() === '') {
-                return { ok: false, error: { code: 'empty-text' } };
-            }
-            if (typeof request.blockedBy === 'string'
-                && !loaded.state.members.some(member => member.name === request.blockedBy)) {
+            if (loaded.state.linked?.some(entry => entry.sessionId === request.target) !== true)
                 return { ok: false, error: { code: 'member-not-found' } };
-            }
-            loaded.session.append('room/task-edited', {
-                id: task.id,
-                ...request.title === undefined ? {} : { title: request.title.trim() },
-                ...request.blockedBy === undefined ? {} : { blockedBy: request.blockedBy },
-            });
+            loaded.session.append('room/help-unlink', { sessionId: request.target });
+            await this.ctx.sessions.flush(loaded.session);
+            return { ok: true };
+        }
+        /**
+         * Dismiss the 加入房间成员 hint for one outside session (it never shows again).
+         * @param request - room session, the outside session.
+         * @returns ok.
+         */
+        async dismissHelpNudge(request) {
+            const loaded = await this.ensureLive(request.sessionId);
+            if (!loaded.ok)
+                return { ok: false, error: loaded.error };
+            if (loaded.state.helpNudgesDismissed?.includes(request.target) === true)
+                return { ok: true };
+            loaded.session.append('room/help-nudge-dismissed', { sessionId: request.target });
+            await this.ctx.sessions.flush(loaded.session);
+            return { ok: true };
+        }
+        /**
+         * Dismiss a pending relay: the notification never reaches anyone.
+         * @param request - room session, relay id.
+         * @returns the resolution receipt, or a rejection.
+         */
+        async dismissRelay(request) {
+            const loaded = await this.ensureLive(request.sessionId);
+            if (!loaded.ok)
+                return { ok: false, error: loaded.error };
+            const relay = loaded.state.relays.find(entry => entry.id === request.relayId);
+            if (relay === undefined)
+                return { ok: false, error: { code: 'relay-not-found' } };
+            if (relay.state !== 'pending')
+                return { ok: false, error: { code: 'relay-not-pending' } };
+            loaded.session.append('room/relay-resolved', { id: relay.id, state: 'dismissed' });
             await this.ctx.sessions.flush(loaded.session);
-            return { ok: true, value: { id: task.id } };
+            // A dismissed help request from another room ends that room's thread.
+            const asked = relay.intent?.help;
+            if (asked !== undefined) {
+                const asking = await this.ensureLive(SessionId(asked.room));
+                if (asking.ok && replayHelps(asking.session.snapshotEvents()).some(entry => entry.id === asked.id)) {
+                    asking.session.append('room/help-state', { help: asked.id, state: 'failed', error: '对方房间没有接这条求助' });
+                    await this.ctx.sessions.flush(asking.session);
+                }
+            }
+            return { ok: true, value: { relayId: relay.id } };
         }
         /**
          * Set (or, with a blank text, clear) the room's goal. The goal is one
@@ -1179,7 +2406,9 @@ let RoomService = (() => {
                 return { ok: true, value: { cancelled: false } };
             }
             const facade = probeLocalAgent(this.ctx);
-            const native = member.kind === 'main-agent' && expected !== undefined ? this.ctx.agents.get(loaded.session.id) : undefined;
+            const native = expected === undefined ? undefined
+                : member.kind === 'main-agent' ? this.ctx.agents.get(loaded.session.id)
+                    : member.kind === 'native' && member.childSessionId !== undefined ? this.ctx.agents.get(member.childSessionId) : undefined;
             if (native !== undefined)
                 native.cancel({ kind: 'user' });
             const hit = native !== undefined || (facade !== undefined && member.childSessionId !== undefined
@@ -1193,15 +2422,8 @@ let RoomService = (() => {
                     member: request.name, state: 'cancelled', startedAt: running.startedAt,
                     elapsedMs: Math.max(0, Date.now() - running.startedAt),
                     ...running.runId === undefined ? {} : { runId: running.runId },
+                    ...this.terminalRunStateFields(loaded.session, loaded.state, request.name),
                 });
-                // The engine's settle no-ops behind this edge, so the task closing the
-                // settle would have done happens here: the dispatch-opened in_progress
-                // task cancels with its run.
-                for (const task of loaded.state.tasks) {
-                    if (task.member === request.name && task.status === 'in_progress' && (running.runId === undefined || task.deliveryId === running.runId)) {
-                        loaded.session.append('room/task-updated', { id: task.id, status: 'cancelled' });
-                    }
-                }
                 await this.ctx.sessions.flush(loaded.session);
                 return { ok: true, value: { cancelled: true } };
             }