@khorsheed/dsh-room 0.2.2 → 0.2.4

package/lib/types/client/index.js

@@ -1,18 +1,25 @@
 import roomRemote from '@khorsheed/dsh-room/remote';
+import { presetDisplayText } from '@deepseek-ai/dsh-agent-preset-registry/display';
 import { RoomRequestIds } from './request-ids.js';
 import { en, zh } from './locales.js';
 import { InviteAgentAction } from './InviteAgentAction.js';
 import { MembersView } from './MembersView.js';
 import { RoomComposer, selectRoomComposer } from './RoomComposer.js';
-import { ROOM_PLAN_KIND, ROOM_PLAN_TAB_ID, RoomPlanTab } from './RoomPlanTab.js';
+import { ROOM_TASKS_KIND, ROOM_TASKS_TAB_ID, RoomTasksTab } from './TasksTab.js';
+import { RoomTaskTags } from './task-tag.js';
 import { RoomSpeechView } from './RoomSpeechView.js';
 import { RoomRunView } from './RoomRunView.js';
 import { RoomEventView } from './RoomEventView.js';
-import { roomEventDefinition, roomRelayDefinition, roomRunDefinition, roomSpeechDefinition, roomTaskLineDefinition } from './nodes.js';
+import { roomApprovalDefinition, roomDecisionDefinition, roomHelpDefinition, roomHelpInDefinition, roomHelpRequestDefinition, roomQuestionDefinition, roomEventDefinition, roomRelayDefinition, roomInboxDefinition, roomRunDefinition, roomSpeechDefinition } from './nodes.js';
 import { mainSessionId, RoomStore } from './room-store.js';
 import { RoomPresetVisibility, RegistrationToggle } from './preset-visibility.js';
 import { RoomRelayView } from './RoomRelayView.js';
-import { RoomTaskLineView } from './RoomTaskLineView.js';
+import { RoomInboxView } from './RoomInboxView.js';
+import { RoomApprovalView } from './RoomApprovalView.js';
+import { RoomQuestionView } from './RoomQuestionView.js';
+import { RoomDecisionView } from './RoomDecisionView.js';
+import { RoomHelpRequestView, RoomHelpView } from './RoomHelpView.js';
+import { sessionTitle } from './at-menu.js';
 /** Dictionary namespace owned by this plugin. */
 const NS = 'room';
 /**
@@ -47,6 +54,13 @@ export async function apply(ctx) {
     const remote = ctx.get('remote.room');
     ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'room: dictionaries');
     const t = ctx.locale.bind(NS);
+    // The host's agent-preset dictionary (ui-agent-preset) carries the shipped
+    // modes' names; an unregistered key reads back as itself — fall back to the id.
+    const hostPresetCopy = ctx.locale.bind('settings.agentPreset');
+    const presetCopy = (key) => {
+        const text = hostPresetCopy(key);
+        return text === key ? '' : text;
+    };
     const roomStore = new RoomStore(ctx, remote);
     ctx.effect(() => roomStore.start(), 'room: store');
     // The M3' self-hide criterion for room's session chrome (the invite chip
@@ -54,12 +68,13 @@ export async function apply(ctx) {
     // RoomStore's cached verdict as the actual-room escape.
     const roomChrome = new RoomPresetVisibility(ctx, sessionId => roomStore.isRoomCached(sessionId) === true);
     const requestIds = new RoomRequestIds();
-    const submit = async (sessionId, text, targets) => {
+    const submit = async (sessionId, text, targets, task) => {
         if (remote === undefined)
             return { ok: false, message: t('composer.error.generic') };
         const requestId = requestIds.forInput(sessionId, text, targets);
         const carried = await remote.postMessage({
             sessionId, text, requestId, ...targets === undefined || targets.length === 0 ? {} : { targets },
+            ...task === undefined ? {} : { task },
         });
         if (!carried.ok)
             return { ok: false, message: t('composer.error.generic') };
@@ -137,31 +152,9 @@ export async function apply(ctx) {
                 void roomStore.refresh(sessionId);
         },
     });
-    /** The task-board actions (sessionId binds per entry inject). */
-    const tasksFace = (sessionId) => ({
+    /** The goal action (sessionId binds per entry inject). */
+    const goalFace = (sessionId) => ({
         roomStore,
-        addTask: async (member, title, blockedBy) => {
-            if (remote === undefined)
-                return { ok: false, message: t('invite.error.generic') };
-            const carried = await remote.addTask({
-                sessionId, member, title, ...blockedBy === undefined ? {} : { blockedBy },
-            });
-            if (!carried.ok || !carried.value.ok)
-                return { ok: false, message: t('invite.error.generic') };
-            void roomStore.refresh(sessionId);
-            return { ok: true };
-        },
-        closeTask: async (taskId, status) => {
-            if (remote === undefined)
-                return { ok: false, message: t('invite.error.generic') };
-            const carried = await remote.closeTask({
-                sessionId, taskId, ...status === undefined ? {} : { status },
-            });
-            if (!carried.ok || !carried.value.ok)
-                return { ok: false, message: t('invite.error.generic') };
-            void roomStore.refresh(sessionId);
-            return { ok: true };
-        },
         setGoal: async (text) => {
             if (remote === undefined)
                 return { ok: false, message: t('invite.error.generic') };
@@ -172,6 +165,7 @@ export async function apply(ctx) {
             return { ok: true };
         },
     });
+    const taskTags = new RoomTaskTags();
     /** Map a structured RoomFailure to the dialog's localized copy. */
     const failureText = (error) => {
         switch (error.code) {
@@ -184,6 +178,7 @@ export async function apply(ctx) {
             case 'configuration-owned-by-core': return t('coordinator.configuration');
             case 'duplicate-name': return t('invite.error.duplicate');
             case 'invalid-name': return t('invite.error.invalid');
+            case 'role-too-long': return t('invite.error.roleTooLong');
             case 'local-agent-unavailable': return t('invite.error.unavailable');
             case 'unknown-provider':
                 return t('invite.error.unknownProvider', {
@@ -218,11 +213,22 @@ export async function apply(ctx) {
             void roomStore.refresh(sessionId);
             return { ok: true, pendingFirstTask: carried.value.value.pendingFirstTask };
         },
-        listProviders: async () => {
+        listProviders: async (sessionId) => {
             if (remote === undefined)
                 return undefined;
-            const carried = await remote.listProviders({});
-            return carried.ok ? carried.value : undefined;
+            const carried = await remote.listProviders(sessionId === undefined ? {} : { sessionId });
+            if (!carried.ok)
+                return undefined;
+            // Mode names as the host's own mode selector shows them: shipped modes
+            // (标准模式, PTC 模式 …) from the host's dictionary, others as declared.
+            const value = carried.value;
+            return value.presets === undefined ? value : {
+                ...value,
+                presets: value.presets.map((row) => {
+                    const shown = presetDisplayText(row, presetCopy);
+                    return { ...row, name: shown.name || row.name || row.id, ...shown.description ? { description: shown.description } : {} };
+                }),
+            };
         },
         browseDirectory: () => {
             // Host 0.1.2 hangs the native picker on ui-workspace's service (the
@@ -250,8 +256,20 @@ export async function apply(ctx) {
         },
         roomChrome,
     });
+    // The team page lives in the right sidebar; without it the members tab
+    // simply shows no 团队 entry.
+    const teamSidebar = ctx.get('sidebarRightTabs') === undefined ? undefined : ctx.get('sidebarRight');
+    // Outside sessions on the member list (「加入房间成员」) and the third ask's hint.
+    const linkFace = (sessionId) => ({
+        linkSession: (target, title) => { void remote?.linkSession({ sessionId, target, title }).then(() => roomStore.refresh(sessionId)); },
+        unlinkSession: (target) => { void remote?.unlinkSession({ sessionId, target }).then(() => roomStore.refresh(sessionId)); },
+        dismissNudge: (target) => { void remote?.dismissHelpNudge({ sessionId, target }).then(() => roomStore.refresh(sessionId)); },
+    });
     const membersFace = (sessionId) => ({
         roomStore,
+        unlinkSession: linkFace(sessionId).unlinkSession,
+        // 团队 is the collaboration page's second view (one sidebar page, two switches).
+        ...teamSidebar === undefined ? {} : { openTeam: (member) => { teamSidebar.openTab(ROOM_TASKS_KIND, { params: { view: 'team', ...member === undefined ? {} : { member } } }); } },
         setCoordinator: async (memberId, expectedRevision) => {
             if (remote === undefined)
                 return { ok: false, message: t('invite.error.generic') };
@@ -304,6 +322,28 @@ export async function apply(ctx) {
             if (!carried.value.ok)
                 return { ok: false, message: failureText(carried.value.error) };
             void roomStore.refresh(sessionId);
+            return { ok: true, value: carried.value.value };
+        },
+        setSettings: async (patch) => {
+            if (remote === undefined)
+                return { ok: false, message: t('invite.error.generic') };
+            const carried = await remote.setSettings({ sessionId, ...patch });
+            if (!carried.ok)
+                return { ok: false, message: t('invite.error.generic') };
+            if (!carried.value.ok)
+                return { ok: false, message: failureText(carried.value.error) };
+            void roomStore.refresh(sessionId);
+            return { ok: true };
+        },
+        restoreMember: async (member) => {
+            if (remote === undefined)
+                return { ok: false, message: t('invite.error.generic') };
+            const carried = await remote.restoreMember({ sessionId, name: member });
+            if (!carried.ok)
+                return { ok: false, message: t('invite.error.generic') };
+            if (!carried.value.ok)
+                return { ok: false, message: failureText(carried.value.error) };
+            void roomStore.refresh(sessionId);
             return { ok: true };
         },
         updateMember: async (member, patch) => {
@@ -314,8 +354,10 @@ export async function apply(ctx) {
                 name: member,
                 ...patch.rename === undefined ? {} : { rename: patch.rename },
                 ...patch.instructions === undefined ? {} : { instructions: patch.instructions },
+                ...patch.role === undefined ? {} : { role: patch.role },
                 ...patch.cwd === undefined ? {} : { cwd: patch.cwd },
                 ...patch.model === undefined ? {} : { model: patch.model },
+                ...patch.effort === undefined ? {} : { effort: patch.effort },
             });
             if (!carried.ok)
                 return { ok: false, message: t('invite.error.generic') };
@@ -334,7 +376,13 @@ export async function apply(ctx) {
         lctx.uiConversation.events.register(roomRunDefinition);
         lctx.uiConversation.events.register(roomEventDefinition);
         lctx.uiConversation.events.register(roomRelayDefinition);
-        lctx.uiConversation.events.register(roomTaskLineDefinition);
+        lctx.uiConversation.events.register(roomInboxDefinition);
+        lctx.uiConversation.events.register(roomApprovalDefinition);
+        lctx.uiConversation.events.register(roomQuestionDefinition);
+        lctx.uiConversation.events.register(roomDecisionDefinition);
+        lctx.uiConversation.events.register(roomHelpDefinition);
+        lctx.uiConversation.events.register(roomHelpRequestDefinition);
+        lctx.uiConversation.events.register(roomHelpInDefinition);
     });
     // The slots are declared by ui-conversation, whose apply order
     // relative to this plugin is unconstrained: register through slots.inject so
@@ -361,48 +409,134 @@ export async function apply(ctx) {
     // main-agent turn Stop: the takeover renders the dock
     // surfaces and the Stop button itself, because their seats hide with the
     // official fallback.
+    const reconcileFor = (sessionId) => async (deliveryId, outcome, evidence) => {
+        const result = await remote?.reconcileDelivery({ sessionId, deliveryId, outcome, evidence });
+        await roomStore.refresh(sessionId);
+        return result?.ok && result.value.ok ? { ok: true } : { ok: false, message: result?.ok && !result.value.ok ? result.value.error.code : t('composer.error.generic') };
+    };
+    /** The task page's actions (sessionId binds per entry inject). */
+    const tasksFace = (sessionId) => ({
+        ...goalFace(sessionId),
+        linkSession: linkFace(sessionId).linkSession,
+        unlinkSession: linkFace(sessionId).unlinkSession,
+        taskTags,
+        stopJob: async (task) => {
+            const carried = await remote?.stopJob({ sessionId, task });
+            await roomStore.refresh(sessionId);
+            return carried?.ok && carried.value.ok ? { ok: true } : { ok: false, message: t('composer.error.generic') };
+        },
+        stopDelivery: (member, deliveryId) => {
+            void remote?.cancel({ sessionId, name: member, ...deliveryId === undefined ? {} : { expectedRunId: deliveryId } }).then(() => roomStore.refresh(sessionId));
+        },
+        reconcile: reconcileFor(sessionId),
+        confirmRelay: relayFace(sessionId).confirmRelay,
+        dismissRelay: relayFace(sessionId).dismissRelay,
+        planCommand: async (command) => {
+            const result = await remote?.planCommand({ sessionId, command });
+            await roomStore.refresh(sessionId);
+            return result?.ok && result.value.ok ? { ok: true } : { ok: false, message: result?.ok && !result.value.ok ? result.value.message : t('composer.error.generic') };
+        },
+        openSession: id => openSession(id),
+    });
     const sidebar = ctx.get('sidebarRight');
     const sidebarTabs = ctx.get('sidebarRightTabs');
+    // The @ menu's other sessions: the host's session-reference candidates
+    // (the recent list merged with the query's own lookup), each flagged when
+    // it is a room (probed once per session and remembered).
+    const roomFlags = new Map();
+    const roomFlag = (id) => {
+        let flag = roomFlags.get(id);
+        if (flag === undefined) {
+            flag = (remote?.isRoom({ sessionId: id }) ?? Promise.resolve(undefined))
+                .then(carried => carried?.ok === true && carried.value === true)
+                .catch(() => false);
+            roomFlags.set(id, flag);
+        }
+        return flag;
+    };
+    const memberLists = new Map();
+    const roomMembers = (id) => {
+        const cached = memberLists.get(id);
+        if (cached !== undefined && Date.now() - cached.at < 30_000)
+            return cached.members;
+        const members = (remote?.getState({ sessionId: id }) ?? Promise.resolve(undefined))
+            .then(carried => carried?.ok === true && carried.value.ok
+            ? carried.value.value.members.map(member => ({ name: member.name, kind: member.kind, ...member.provider === undefined ? {} : { provider: member.provider } }))
+            : [])
+            .catch(() => []);
+        memberLists.set(id, { at: Date.now(), members });
+        return members;
+    };
+    const listSessionsFor = async (sessionId, query, signal) => {
+        // A Remote call resolves to a RemoteResult ({ ok, value }), never the bare list.
+        const resolver = ctx.get('remote.sessionReferenceResolver');
+        if (resolver?.candidates === undefined)
+            return [];
+        const lookup = (text) => resolver.candidates(sessionId, text, signal)
+            .then(result => result.ok && Array.isArray(result.value) ? result.value : []);
+        const [recent, matched] = await Promise.all([lookup(''), query === '' ? Promise.resolve([]) : lookup(query)]);
+        // Archived sessions cannot be opened or woken: never offer one.
+        const workspaces = ctx.get('workspaces');
+        const archived = new Set(workspaces?.list?.getSnapshot?.().archivedSessionIds ?? []);
+        const merged = [...recent, ...matched].filter(candidate => !archived.has(candidate.sessionId));
+        const flags = await Promise.all(merged.map(candidate => roomFlag(candidate.sessionId)));
+        // A room carries its members (askable by name): one getState per room, kept 30s.
+        return Promise.all(merged.map(async (candidate, index) => flags[index] === true
+            ? { ...candidate, room: true, members: await roomMembers(candidate.sessionId) }
+            : candidate));
+    };
     const composerEntry = {
         name: 'conversation.composer',
         priority: -10,
         locale: NS,
         select: (owner) => selectRoomComposer(owner, id => roomStore.isRoomCached(id) === true),
         inject: (sessionId) => ({
-            ...tasksFace(sessionId),
+            ...goalFace(sessionId),
             ...inviteFace(sessionId),
-            reconcileDelivery: async (deliveryId, outcome, evidence) => {
-                const result = await remote?.reconcileDelivery({ sessionId, deliveryId, outcome, evidence });
-                await roomStore.refresh(sessionId);
-                return result?.ok && result.value.ok ? { ok: true } : { ok: false, message: result?.ok && !result.value.ok ? result.value.error.code : t('composer.error.generic') };
-            },
-            planCommand: async (command) => {
-                const result = await remote?.planCommand({ sessionId, command });
-                await roomStore.refresh(sessionId);
-                return result?.ok && result.value.ok ? { ok: true } : { ok: false, message: result?.ok && !result.value.ok ? result.value.message : t('composer.error.generic') };
-            },
+            reconcileDelivery: reconcileFor(sessionId),
             openPlanSession: id => openSession(id),
-            backgroundSessions: ctx.sessions.list,
-            activeChildren: async () => {
-                const gateway = ctx.get('remote.localAgentGateway');
-                const result = await gateway?.activeDelegations?.();
-                return result?.ok ? result.value : undefined;
-            },
-            stopChild: async (childSessionId) => {
-                const result = await remote?.cancelChild({ sessionId, childSessionId: childSessionId });
-                return result?.ok && result.value.ok && result.value.value.cancelled ? { ok: true } : { ok: false, message: t('activity.stopChanged') };
-            },
-            ...sidebar === undefined || sidebarTabs === undefined ? {} : { openPlan: () => { sidebar.openTab(ROOM_PLAN_KIND, { params: {} }); } },
-            stopExecution: async (name, run) => {
-                const result = await remote?.cancel({ sessionId, name, expectedStartedAt: run.startedAt, ...run.runId === undefined ? {} : { expectedRunId: run.runId } });
-                await roomStore.refresh(sessionId);
-                return result?.ok && result.value.ok && result.value.value.cancelled ? { ok: true } : { ok: false, message: t('activity.stopChanged') };
+            ...sidebar === undefined || sidebarTabs === undefined ? {} : {
+                openTasks: (task) => { sidebar.openTab(ROOM_TASKS_KIND, { params: { view: 'tasks', ...task === undefined ? {} : { task } } }); },
             },
+            taskTags,
             submit,
             renderMemberConfiguration: ctx.get('localAgentUi')?.renderMemberConfiguration,
             renderMemberInbox: ctx.get('localAgentUi')?.renderMemberInbox,
             stopMember: (name, expectedRunId) => { void remote?.cancel({ sessionId, name, ...expectedRunId === undefined ? {} : { expectedRunId } }).then(() => roomStore.refresh(sessionId)); },
             modelDirectory: modelDirectoryFor(sessionId),
+            // A draft chip's preview: the official editor's chip click routes
+            // through the session's input-trigger controller to the chip's owning
+            // source — probed at click time, so a composition without the service
+            // (or a torn-down scope) just declines.
+            ...ctx.get('remote.sessionReferenceResolver') === undefined ? {} : {
+                listSessions: (query, signal) => listSessionsFor(sessionId, query, signal),
+                insertSessionReference: (candidate, span) => {
+                    try {
+                        const scope = ctx.sessions.scope(sessionId);
+                        if (scope?.bail === undefined)
+                            return false;
+                        return scope.bail(scope, 'slash/input-insert-reference', {
+                            reference: { source: 'reference', ref: candidate.mention, label: sessionTitle(candidate), appearance: 'session', clipboardText: candidate.mention },
+                            span,
+                        }) === true;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+            },
+            openReference: (source, ref) => {
+                try {
+                    const scope = ctx.sessions.scope(sessionId);
+                    const triggers = ctx.get('inputTriggers');
+                    if (scope === undefined || triggers === undefined)
+                        return false;
+                    return triggers.sessionOf(scope).openReference(source, { ref });
+                }
+                catch {
+                    return false;
+                }
+            },
             // The hidden official bar's Stop: the runtime session face's cancel
             // (the same verb ui-conversation's own Stop injects). A torn-down
             // binding degrades to a no-op.
@@ -414,17 +548,14 @@ export async function apply(ctx) {
         }),
     };
     if (sidebar !== undefined && sidebarTabs !== undefined) {
-        const planToggle = new RegistrationToggle(() => sidebarTabs.register({ id: ROOM_PLAN_TAB_ID, kind: ROOM_PLAN_KIND, title: () => t('activity.plan') }), () => roomChrome.show(mainSessionId(ctx.sessions.list.getSnapshot())));
-        planToggle.setReady(true);
-        const unsubscribe = roomChrome.subscribe(() => planToggle.sync());
-        disposers.push(async () => { unsubscribe(); planToggle.setReady(false); });
+        const tasksToggle = new RegistrationToggle(() => sidebarTabs.register({ id: ROOM_TASKS_TAB_ID, kind: ROOM_TASKS_KIND, title: () => t('collab.title') }), () => roomChrome.show(mainSessionId(ctx.sessions.list.getSnapshot())));
+        tasksToggle.setReady(true);
+        const unsubscribe = roomChrome.subscribe(() => tasksToggle.sync());
+        disposers.push(async () => { unsubscribe(); tasksToggle.setReady(false); });
         ctx.slots.inject('sidebar.right.pane.tab', () => ctx.slots.register({
-            name: 'sidebar.right.pane.tab', key: ROOM_PLAN_TAB_ID, locale: NS,
-            inject: (sessionId) => {
-                const { roomStore, planCommand, openPlanSession, stopMember } = composerEntry.inject(sessionId);
-                return { roomStore, planCommand, openPlanSession, stopMember };
-            },
-        }, RoomPlanTab));
+            name: 'sidebar.right.pane.tab', key: ROOM_TASKS_TAB_ID, locale: NS,
+            inject: (sessionId) => tasksFace(sessionId),
+        }, RoomTasksTab));
     }
     let composerDispose;
     ctx.slots.inject('conversation.composer', () => {
@@ -470,7 +601,20 @@ export async function apply(ctx) {
         name: 'conversation.chat.node',
         key: 'room-speech',
         locale: NS,
-        inject: () => ({ roomStore, openSession }),
+        inject: () => ({
+            roomStore,
+            openSession,
+            // Context Lens is another plugin: reach it through the sidebar by its
+            // tab kind, only when its namespace is mounted; a refused open is a no-op.
+            ...ctx.get('remote.requestInspector') === undefined || ctx.get('sidebarRight') === undefined ? {} : {
+                openDetail: (sessionId, messageId) => {
+                    try {
+                        ctx.get('sidebarRight').openTab('context-lens', { params: { sessionId, messageId } });
+                    }
+                    catch { /* the tab kind is hidden or absent */ }
+                },
+            },
+        }),
     }, RoomSpeechView));
     ctx.slots.inject('conversation.chat.node', () => ctx.slots.register({
         name: 'conversation.chat.node',
@@ -492,10 +636,70 @@ export async function apply(ctx) {
     }, RoomRelayView));
     ctx.slots.inject('conversation.chat.node', () => ctx.slots.register({
         name: 'conversation.chat.node',
-        key: 'room-task-line',
+        key: 'room-inbox',
+        locale: NS,
+        inject: (sessionId) => ({
+            releaseReports: async (member) => {
+                if (remote === undefined)
+                    return;
+                const carried = await remote.releaseReports({ sessionId, name: member });
+                if (carried.ok)
+                    void roomStore.refresh(sessionId);
+            },
+        }),
+    }, RoomInboxView));
+    ctx.slots.inject('conversation.chat.node', () => ctx.slots.register({
+        name: 'conversation.chat.node',
+        key: 'room-approval',
+        locale: NS,
+        inject: (sessionId) => ({
+            answerApproval: async (approvalId, outcome) => {
+                if (remote === undefined)
+                    return t('composer.error.generic');
+                const carried = await remote.answerApproval({ sessionId, id: approvalId, outcome });
+                void roomStore.refresh(sessionId);
+                if (!carried.ok)
+                    return t('composer.error.generic');
+                return carried.value.ok ? undefined : t('approval.expired');
+            },
+        }),
+    }, RoomApprovalView));
+    ctx.slots.inject('conversation.chat.node', () => ctx.slots.register({
+        name: 'conversation.chat.node',
+        key: 'room-question',
         locale: NS,
-        inject: () => ({ roomStore }),
-    }, RoomTaskLineView));
+        inject: (sessionId) => ({
+            answerQuestion: async (questionId, answers) => {
+                if (remote === undefined)
+                    return t('composer.error.generic');
+                const carried = await remote.answerQuestion({ sessionId, id: questionId, answers });
+                void roomStore.refresh(sessionId);
+                if (!carried.ok)
+                    return t('composer.error.generic');
+                return carried.value.ok ? undefined : t('question.expired');
+            },
+        }),
+    }, RoomQuestionView));
+    ctx.slots.inject('conversation.chat.node', () => ctx.slots.register({
+        name: 'conversation.chat.node',
+        key: 'room-decision',
+        locale: NS,
+        inject: (sessionId) => ({
+            // Context Lens is another plugin: opened by its tab kind, only when mounted.
+            ...ctx.get('remote.requestInspector') === undefined || ctx.get('sidebarRight') === undefined ? {} : {
+                openDecision: (decisionId) => {
+                    try {
+                        ctx.get('sidebarRight').openTab('context-lens', { params: { sessionId, roomDecision: decisionId } });
+                    }
+                    catch { /* the tab kind is hidden or absent */ }
+                },
+            },
+        }),
+    }, RoomDecisionView));
+    // Cross-session help: the thread row in the asking room, the request card
+    // in the helper's session (any session — the card is how it gets there).
+    ctx.slots.inject('conversation.chat.node', () => ctx.slots.register({ name: 'conversation.chat.node', key: 'room-help', locale: NS, inject: (sessionId) => ({ openSession, roomStore, linkSession: linkFace(sessionId).linkSession, dismissNudge: linkFace(sessionId).dismissNudge }) }, RoomHelpView));
+    ctx.slots.inject('conversation.chat.node', () => ctx.slots.register({ name: 'conversation.chat.node', key: 'room-help-request', locale: NS, inject: () => ({ openSession }) }, RoomHelpRequestView));
     return async () => {
         for (const dispose of disposers.reverse())
             await dispose();