@khorsheed/dsh-room 0.1.1 → 0.2.1

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

@@ -0,0 +1,50 @@
+import type { RoomExecution, RoomState } from '../types.ts';
+export interface ExecutionRow {
+    sessionTotal?: boolean;
+    id: string;
+    member: string;
+    childSessionId?: string;
+    title: string;
+    status: 'queued' | 'running' | 'done' | 'cancelled' | 'failed' | 'uncertain' | 'submitted' | 'accepted' | 'settled';
+    provider?: string;
+    model?: string;
+    effort?: string;
+    tokens?: number;
+    startedAt?: number;
+    elapsedMs?: number;
+    error?: string;
+    execution?: RoomExecution;
+}
+/** Public session-list projection; members are deduplicated against durable Room executions. */
+export interface BackgroundSession {
+    id: string;
+    parentId?: string;
+    origin?: string;
+    displayTitle?: string;
+    running?: boolean;
+    projectionValues?: {
+        tokenUsage?: {
+            uncachedInputTokens: number;
+            outputTokens: number;
+            cacheReadTokens: number;
+            cacheWriteTokens: number;
+        };
+        subagentTiming?: {
+            settledMs: number;
+            active?: {
+                since: number;
+                through: number;
+            };
+        };
+    };
+}
+export interface BackgroundSessionsStore {
+    subscribe(listener: () => void): () => void;
+    getSnapshot(): {
+        byId: Readonly<Record<string, BackgroundSession>>;
+    };
+}
+export declare function descendantRows(sessions: Readonly<Record<string, BackgroundSession>>, root: string, state: RoomState, now: number, active?: readonly string[]): ExecutionRow[];
+/** One row per delivery/attempt, not one row per persistent member session. */
+export declare function executionRows(state: RoomState): ExecutionRow[];
+//# sourceMappingURL=executions.d.ts.map

package/lib/types/client/executions.js

@@ -0,0 +1,70 @@
+export function descendantRows(sessions, root, state, now, active = []) {
+    const known = new Set([...state.members.map(member => member.childSessionId), ...(state.executions ?? []).map(run => run.childSessionId)]);
+    const representedRunning = new Set(executionRows(state).filter(row => row.status === 'running').map(row => row.childSessionId));
+    const coordinatorChild = state.members.find(member => state.coordinator === undefined ? member.kind === 'main-agent' : member.id === state.coordinator.memberId)?.childSessionId;
+    const result = [];
+    const seen = new Set([root]);
+    const visit = (parent) => {
+        for (const child of Object.values(sessions)) {
+            if (child.parentId !== parent || child.origin !== 'subagent' || seen.has(child.id))
+                continue;
+            seen.add(child.id);
+            const running = child.running === true || active.includes(child.id);
+            // Direct follow-ups in a member's own composer bypass Room dispatch.
+            // Keep that live session visible without duplicating an active Room execution.
+            if (child.id !== coordinatorChild && (!known.has(child.id) || (running && !representedRunning.has(child.id)))) {
+                const timing = child.projectionValues?.subagentTiming;
+                const usage = child.projectionValues?.tokenUsage;
+                const elapsedMs = timing === undefined ? undefined : timing.settledMs + (timing.active === undefined ? 0 : Math.max(0, (running ? now : timing.active.through) - timing.active.since));
+                const tokens = usage === undefined ? undefined : usage.uncachedInputTokens + usage.outputTokens + usage.cacheReadTokens + usage.cacheWriteTokens;
+                result.push({ id: `session:${child.id}`, member: child.displayTitle || child.id, title: child.displayTitle || child.id, childSessionId: child.id,
+                    status: running ? 'running' : 'settled', sessionTotal: true,
+                    ...elapsedMs === undefined ? {} : { elapsedMs },
+                    ...tokens === undefined || !Number.isFinite(tokens) ? {} : { tokens },
+                });
+            }
+            visit(child.id);
+        }
+    };
+    visit(root);
+    return result;
+}
+/** One row per delivery/attempt, not one row per persistent member session. */
+export function executionRows(state) {
+    const coordinator = state.members.find(member => state.coordinator === undefined ? member.kind === 'main-agent' : member.id === state.coordinator.memberId);
+    const history = new Map((state.executions ?? state.runs.map(run => ({ ...run, id: run.runId ?? `${run.member}:${run.startedAt}` }))).map(run => [run.id, run]));
+    const rows = [];
+    for (const delivery of state.deliveries ?? []) {
+        const execution = history.get(delivery.id);
+        history.delete(delivery.id);
+        const member = state.members.find(member => member.id === delivery.memberId);
+        if ((coordinator !== undefined && delivery.memberId === coordinator.id) || delivery.origin === 'report')
+            continue;
+        const task = delivery.plan?.goalId === state.plan?.id ? state.plan?.tasks.find(task => task.id === delivery.plan?.taskId) : undefined;
+        const attempt = task?.attempts.find(attempt => attempt.id === delivery.plan?.attemptId);
+        const terminal = delivery.status === 'done' && attempt !== undefined
+            ? attempt.status === 'accepted' ? 'accepted' : attempt.status === 'submitted' ? 'submitted' : 'done'
+            : delivery.status;
+        const status = execution?.state === 'failed' && delivery.status === 'running' ? 'uncertain' : terminal;
+        const title = task?.title ?? state.tasks.find(task => task.deliveryId === delivery.id)?.title ?? delivery.text;
+        rows.push({ title: title.replace(/\s+/g, ' ').trim(),
+            ...member?.provider === undefined ? {} : { provider: member.provider },
+            ...execution,
+            // Execution identity is immutable; delivery/review state is authoritative.
+            id: delivery.id, status, member: member?.name ?? execution?.member ?? delivery.memberId,
+            ...execution === undefined ? {} : { execution },
+            ...execution?.childSessionId !== undefined || member?.childSessionId === undefined ? {} : { childSessionId: member.childSessionId },
+            ...delivery.error === undefined ? {} : { error: delivery.error },
+        });
+    }
+    for (const execution of history.values()) {
+        const member = state.members.find(member => member.id === execution.memberId || (execution.memberId === undefined && member.name === execution.member));
+        if (coordinator !== undefined && member === coordinator)
+            continue;
+        rows.push({ ...execution, execution, title: state.tasks.find(task => task.deliveryId === execution.runId)?.title ?? execution.member,
+            status: execution.state, member: member?.name ?? execution.member,
+            ...execution.childSessionId !== undefined || member?.childSessionId === undefined ? {} : { childSessionId: member.childSessionId },
+        });
+    }
+    return rows.reverse();
+}

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

@@ -4,7 +4,7 @@
  * registers the slot entries: the session-header「邀请 agent」action and the
  * 成员 `conversation.view` tab — both self-hiding by the current session's
  * preset composition (M3': visible exactly when the composition names the
- * `@khorsheed/dsh-room-tool` row, fail-open on every unreadable path, and
+ * `@khorsheed/dsh-room/tool` row, fail-open on every unreadable path, and
  * always visible inside an actual room) — plus the `conversation.composer`
  * chain takeover (claims the composer exactly when the current session is a
  * cached room — and renders the dock capsules plus the session stats row

package/lib/types/client/index.js

@@ -4,6 +4,7 @@ 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 { RoomSpeechView } from './RoomSpeechView.js';
 import { RoomRunView } from './RoomRunView.js';
 import { RoomEventView } from './RoomEventView.js';
@@ -360,6 +361,8 @@ 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 sidebar = ctx.get('sidebarRight');
+    const sidebarTabs = ctx.get('sidebarRightTabs');
     const composerEntry = {
         name: 'conversation.composer',
         priority: -10,
@@ -379,10 +382,26 @@ export async function apply(ctx) {
                 return result?.ok && result.value.ok ? { ok: true } : { ok: false, message: result?.ok && !result.value.ok ? result.value.message : t('composer.error.generic') };
             },
             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') };
+            },
             submit,
             renderMemberConfiguration: ctx.get('localAgentUi')?.renderMemberConfiguration,
             renderMemberInbox: ctx.get('localAgentUi')?.renderMemberInbox,
-            stopMember: name => { void remote?.cancel({ sessionId, name }).then(() => roomStore.refresh(sessionId)); },
+            stopMember: (name, expectedRunId) => { void remote?.cancel({ sessionId, name, ...expectedRunId === undefined ? {} : { expectedRunId } }).then(() => roomStore.refresh(sessionId)); },
             modelDirectory: modelDirectoryFor(sessionId),
             // The hidden official bar's Stop: the runtime session face's cancel
             // (the same verb ui-conversation's own Stop injects). A torn-down
@@ -394,6 +413,19 @@ 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); });
+        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));
+    }
     let composerDispose;
     ctx.slots.inject('conversation.composer', () => {
         composerDispose = ctx.slots.register(composerEntry, RoomComposer);

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

@@ -1,6 +1,31 @@
 /** `room` namespace dictionaries. */
 /** Simplified Chinese dictionary (the key-set source of truth). */
 export declare const zh: {
+    'activity.status.settled': string;
+    'activity.sessionTotal': string;
+    "activity.agents": string;
+    "activity.plan": string;
+    "activity.planDetails": string;
+    "activity.limits": string;
+    "activity.session": string;
+    "activity.stop": string;
+    "activity.stopChanged": string;
+    "activity.runningHint": string;
+    "activity.notStarted": string;
+    "activity.empty": string;
+    "activity.planning": string;
+    "activity.filter.recent": string;
+    "activity.filter.running": string;
+    "activity.filter.attention": string;
+    "activity.filter.all": string;
+    "activity.status.queued": string;
+    "activity.status.running": string;
+    "activity.status.done": string;
+    "activity.status.cancelled": string;
+    "activity.status.failed": string;
+    "activity.status.uncertain": string;
+    "activity.status.submitted": string;
+    "activity.status.accepted": string;
     'recovery.title': string;
     'recovery.help': string;
     'recovery.done': string;
@@ -215,6 +240,31 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
 }
 /** English dictionary, checked complete against the zh key set. */
 export declare const en: {
+    'activity.status.settled': string;
+    'activity.sessionTotal': string;
+    "activity.agents": string;
+    "activity.plan": string;
+    "activity.planDetails": string;
+    "activity.limits": string;
+    "activity.session": string;
+    "activity.stop": string;
+    "activity.stopChanged": string;
+    "activity.runningHint": string;
+    "activity.notStarted": string;
+    "activity.empty": string;
+    "activity.planning": string;
+    "activity.filter.recent": string;
+    "activity.filter.running": string;
+    "activity.filter.attention": string;
+    "activity.filter.all": string;
+    "activity.status.queued": string;
+    "activity.status.running": string;
+    "activity.status.done": string;
+    "activity.status.cancelled": string;
+    "activity.status.failed": string;
+    "activity.status.uncertain": string;
+    "activity.status.submitted": string;
+    "activity.status.accepted": string;
     'recovery.title': string;
     'recovery.help': string;
     'recovery.done': string;

package/lib/types/client/locales.js

@@ -1,6 +1,31 @@
 /** `room` namespace dictionaries. */
 /** Simplified Chinese dictionary (the key-set source of truth). */
 export const zh = {
+    'activity.status.settled': '已结束',
+    'activity.sessionTotal': '会话累计',
+    "activity.agents": "后台 Agent",
+    "activity.plan": "当前计划",
+    "activity.planDetails": "计划详情与运行限制",
+    "activity.limits": "运行限制",
+    "activity.session": "查看会话",
+    "activity.stop": "中止",
+    "activity.stopChanged": "这次执行已结束或已发生变化，请查看最新状态。",
+    "activity.runningHint": "{count} 个 Agent 正在运行",
+    "activity.notStarted": "尚未开始",
+    "activity.empty": "当前没有这类执行记录",
+    "activity.planning": "协调者正在整理计划",
+    "activity.filter.recent": "最近",
+    "activity.filter.running": "进行中",
+    "activity.filter.attention": "待处理",
+    "activity.filter.all": "全部",
+    "activity.status.queued": "排队中",
+    "activity.status.running": "运行中",
+    "activity.status.done": "已完成",
+    "activity.status.cancelled": "已中止",
+    "activity.status.failed": "失败",
+    "activity.status.uncertain": "待核对",
+    "activity.status.submitted": "待验收",
+    "activity.status.accepted": "已验收",
     'recovery.title': '中断的对话需要对账',
     'recovery.help': '重启前的结果尚未确认，不会自动重试。请查看成员会话并填写核对结论；对账后，已排队的普通对话可以继续，正式目标仍遵守暂停状态。',
     'recovery.done': '确认已完成',
@@ -207,6 +232,31 @@ export const zh = {
 };
 /** English dictionary, checked complete against the zh key set. */
 export const en = {
+    'activity.status.settled': 'Finished',
+    'activity.sessionTotal': 'Session total',
+    "activity.agents": "Background agents",
+    "activity.plan": "Current plan",
+    "activity.planDetails": "Plan details and limits",
+    "activity.limits": "Run limits",
+    "activity.session": "View conversation",
+    "activity.stop": "Stop",
+    "activity.stopChanged": "This execution has ended or changed. Check its latest state.",
+    "activity.runningHint": "{count} agents are running",
+    "activity.notStarted": "Not started",
+    "activity.empty": "No matching executions",
+    "activity.planning": "The coordinator is preparing the plan",
+    "activity.filter.recent": "Recent",
+    "activity.filter.running": "Running",
+    "activity.filter.attention": "Needs attention",
+    "activity.filter.all": "All",
+    "activity.status.queued": "Queued",
+    "activity.status.running": "Running",
+    "activity.status.done": "Completed",
+    "activity.status.cancelled": "Stopped",
+    "activity.status.failed": "Failed",
+    "activity.status.uncertain": "Needs reconciliation",
+    "activity.status.submitted": "Awaiting review",
+    "activity.status.accepted": "Accepted",
     'recovery.title': 'Interrupted conversations need reconciliation',
     'recovery.help': 'The pre-restart outcome is unknown and will not be retried automatically. Inspect the member session and record your finding. Reconciliation releases queued ordinary conversations; paused goals remain paused.',
     'recovery.done': 'Confirm completed',

package/lib/types/client/preset-visibility.d.ts

@@ -2,7 +2,7 @@
  * The preset-composition visibility of room's SESSION chrome (M3' self-hide,
  * the mode-switcher proposal's "组合里有我的行"): the invite chip and the
  * members tab show exactly when the CURRENT session's preset composition
- * names the `@khorsheed/dsh-room-tool` row — the preset composition file is
+ * names the `@khorsheed/dsh-room/tool` row — the preset composition file is
  * the single source of truth, read from the official `pluginInventory`
  * Remote (the same criterion the worktrees badge implements; inlined here
  * rather than extracted into a helper package, per the proposal's M3'
@@ -16,8 +16,8 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
-/** The composition criterion's row: room's companion tool package. */
-export declare const ROOM_TOOL_ROW_MODULE = "@khorsheed/dsh-room-tool";
+/** The composition criterion's row: this package's own `./tool` composition entry. */
+export declare const ROOM_TOOL_ROW_MODULE = "@khorsheed/dsh-room/tool";
 /**
  * Minimal structural mirror of the official pluginInventory snapshot — only
  * the agentPresets slice the criterion reads (duck-typed, host-version

package/lib/types/client/preset-visibility.js

@@ -1,5 +1,5 @@
-/** The composition criterion's row: room's companion tool package. */
-export const ROOM_TOOL_ROW_MODULE = '@khorsheed/dsh-room-tool';
+/** The composition criterion's row: this package's own `./tool` composition entry. */
+export const ROOM_TOOL_ROW_MODULE = '@khorsheed/dsh-room/tool';
 /** The current session's agent preset, the badge's dual read per host line. */
 function presetOf(row) {
     const value = row

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

@@ -160,12 +160,17 @@ export interface RoomModelDirectory {
  * ui-model-selection — the picker simply does not render.
  */
 export interface RoomComposerInjected extends RoomTasksInjected, RoomInviteInjected {
+    readonly backgroundSessions?: import('./executions.ts').BackgroundSessionsStore | undefined;
+    readonly activeChildren?: (() => Promise<readonly string[] | undefined>) | undefined;
+    readonly stopChild?: ((childSessionId: string) => Promise<RoomMutationOutcome>) | undefined;
+    readonly openPlan?: (() => void) | undefined;
+    readonly stopExecution?: ((name: string, run: import('../types.ts').RoomMemberRun) => Promise<RoomMutationOutcome>) | undefined;
     readonly reconcileDelivery?: ((deliveryId: string, outcome: 'done' | 'cancelled', evidence: string) => Promise<RoomMutationOutcome>) | undefined;
     readonly planCommand?: ((command: string) => Promise<RoomMutationOutcome>) | undefined;
     readonly openPlanSession?: ((sessionId: string) => void) | undefined;
     readonly renderMemberInbox?: LocalAgentUi['renderMemberInbox'] | undefined;
     readonly renderMemberConfiguration?: LocalAgentUi['renderMemberConfiguration'] | undefined;
-    readonly stopMember?: ((name: string) => void) | undefined;
+    readonly stopMember?: ((name: string, expectedRunId?: string) => void) | undefined;
     /**
      * Dispatch an @-message into the room and refresh the store on success.
      * Bare messages never reach here — the composer releases them to the

package/lib/types/dispatch.js

@@ -191,6 +191,12 @@ export class DispatchEngine {
         const error = 'Execution outcome is unknown after restart; reconcile before retrying';
         return {
             ...state,
+            ...state.executions === undefined ? {} : { executions: state.executions.map(execution => {
+                    const active = execution.runId === undefined
+                        ? [...this.inFlight.values()].includes(`${sessionId} ${execution.memberId}`)
+                        : this.scheduled.has(`${sessionId}:${execution.runId}`);
+                    return execution.state === 'running' && !active ? { ...execution, state: 'failed', error } : execution;
+                }) },
             ...state.deliveries === undefined ? {} : { deliveries: state.deliveries.map(row => row.status === 'queued' && closedGoal(state, row.plan?.goalId)
                     ? { ...row, status: 'cancelled' } : row.status === 'running' && !this.scheduled.has(`${sessionId}:${row.id}`)
                     ? { ...row, status: 'uncertain', error } : row) },
@@ -269,7 +275,9 @@ export class DispatchEngine {
             if (deliveryId !== undefined)
                 room.append('room/delivery-state', { id: deliveryId, dispatchSeq: options.dispatchSeq, memberId: identity, state: 'running' });
             memberName = replay(room.snapshotEvents()).members.find(entry => memberId(room.snapshotEvents(), entry) === identity)?.name ?? memberName;
-            room.append('room/run-state', { member: memberName, state: 'running', startedAt, runId });
+            room.append('room/run-state', { member: memberName, state: 'running', startedAt, runId,
+                ...member.kind === 'main-agent' ? { childSessionId: room.id } : member.childSessionId === undefined ? {} : { childSessionId: member.childSessionId },
+            });
             await this.hooks.admitted?.(room, options.dispatchSeq);
             await this.ctx.sessions.flush(room);
             return startedAt;
@@ -278,7 +286,7 @@ export class DispatchEngine {
         try {
             outcome = member.kind === 'main-agent'
                 ? await this.runMainAgent(room, member, cursor, text, await admitted(), options.relayIds ?? [])
-                : await this.runCliMember(room, member, cursor, text, admitted, options.relayIds ?? [], submitted);
+                : await this.runCliMember(room, member, cursor, text, admitted, options.relayIds ?? [], submitted, runId);
         }
         catch (error) {
             this.ctx.logger.warn(`room: dispatch to "${memberName}" failed: ${String(error)}`);
@@ -351,7 +359,7 @@ export class DispatchEngine {
         return { state: 'done' };
     }
     /** CLI member turn: facade start (first round) or resume, then the speech mirror. */
-    async runCliMember(room, member, cursor, text, admitted, relayIds, submitted) {
+    async runCliMember(room, member, cursor, text, admitted, relayIds, submitted, runId) {
         const facade = probeLocalAgent(this.ctx);
         if (facade === undefined) {
             this.ctx.logger.warn(`room: cannot dispatch to "${member.name}": local-agent facade unavailable`);
@@ -363,7 +371,23 @@ export class DispatchEngine {
         // configuration admit the request. Persistence must finish before native work.
         let startedAt;
         const controlled = facade.supportsMemberConfiguration?.(provider) === true;
-        const admission = controlled ? { onAdmitted: async () => { startedAt = await admitted(); } } : {};
+        const admission = {
+            ...controlled ? { onAdmitted: async () => { startedAt = await admitted(); } } : {},
+            onProgress: (event) => {
+                if (event.kind !== 'settled')
+                    return;
+                const previous = room.snapshotEvents().filter(row => row.type === 'room/run-state' && row.data.runId === runId).at(-1);
+                if (previous?.type !== 'room/run-state')
+                    return;
+                const total = event.usage?.totalTokens ?? (event.usage === undefined ? undefined : event.usage.inputTokens + event.usage.outputTokens);
+                room.append('room/execution-metadata', { runId,
+                    ...event.observedModel === undefined ? {} : { model: event.observedModel },
+                    ...event.observedEffort === undefined ? {} : { effort: event.observedEffort },
+                    ...total === undefined || !Number.isFinite(total) || total < 0 ? {} : { tokens: total },
+                });
+                void this.ctx.sessions.flush(room).catch(error => this.ctx.logger.warn(`room: execution metadata flush failed: ${String(error)}`));
+            },
+        };
         if (!controlled)
             startedAt = await admitted();
         const { prompt, carried } = assemblePrompt(room, member, cursor, text, relayIds);
@@ -374,8 +398,8 @@ export class DispatchEngine {
                 // The invite-time model lands as the delegation's own model: the facade
                 // records it with the first start and every later resume re-requests it
                 // (providers bind it at spawn for exec and live alike).
-                ? facade.start(room.id, provider, [{ type: 'text', text: prompt }], member.model === undefined && member.cwd === undefined && !controlled ? undefined : { ...admission, ...member.model === undefined ? {} : { model: member.model }, ...member.cwd === undefined ? {} : { cwd: member.cwd } })
-                : facade.resume(room.id, provider, member.childSessionId, [{ type: 'text', text: prompt }], member.cwd === undefined && !controlled ? undefined : { ...admission, ...member.cwd === undefined ? {} : { cwd: member.cwd } });
+                ? facade.start(room.id, provider, [{ type: 'text', text: prompt }], { ...admission, ...member.model === undefined ? {} : { model: member.model }, ...member.cwd === undefined ? {} : { cwd: member.cwd } })
+                : facade.resume(room.id, provider, member.childSessionId, [{ type: 'text', text: prompt }], { ...admission, ...member.cwd === undefined ? {} : { cwd: member.cwd } });
         // Existing members can enter core's queue immediately. A fresh/prepared
         // identity must publish its first handle before the next submission resumes it.
         if (controlled && member.childSessionId !== undefined && !prepared)

package/lib/types/index.d.ts

@@ -296,6 +296,11 @@ export declare class RoomService extends TypertRemoteService {
      * @returns the cancellation receipt, or a rejection.
      */
     cancel(request: RoomCancelRequest): Promise<RoomCancelResult>;
+    /** Native descendant controls share the host's continuation and cancellation channels. */
+    cancelChild(request: {
+        sessionId: SessionId;
+        childSessionId: SessionId;
+    }): Promise<RoomCancelResult>;
 }
 export default RoomService;
 //# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -44,8 +44,8 @@ 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
  * registration in the M4' tool-row split — their definition factories live
- * in ./tool.ts and the companion `@khorsheed/dsh-room-tool` mounts them
- * inside agent-preset compositions.) The room's entire state is the session's `room/*` custom-event
+ * 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
  * journal (log-only events — persistence and reload-replay come free, the
  * model never sees them, and harnesses without this plugin replay the session
  * safely); every read folds the journal through the pure replay, and every
@@ -126,6 +126,7 @@ let RoomService = (() => {
     let _closeTask_decorators;
     let _setGoal_decorators;
     let _cancel_decorators;
+    let _cancelChild_decorators;
     return class RoomService extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
@@ -146,6 +147,7 @@ let RoomService = (() => {
             _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, _getState_decorators, { kind: "method", name: "getState", static: false, private: false, access: { has: obj => "getState" in obj, get: obj => obj.getState }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -163,6 +165,7 @@ let RoomService = (() => {
             __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);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         static inject = ['sessions', 'agents'];
@@ -232,9 +235,10 @@ let RoomService = (() => {
                 return { kind: 'enter', messages: [] };
             });
             // The model-facing room tools are deliberately NOT registered here: they
-            // moved to the companion `@khorsheed/dsh-room-tool`, which mounts the
-            // tool row inside agent-preset compositions (session-granted). The
-            // definition factories stay exported from ./tool.ts for that companion.
+            // belong to this package's `./tool` composition entry (src/tool.ts),
+            // which mounts the tool row inside agent-preset compositions
+            // (session-granted). The definition factories live in
+            // ./tool-definition.ts for that row.
         }
         /** Resolve a LIVE session as a room: presence, marker, replayed state. */
         load(sessionId) {
@@ -1169,16 +1173,25 @@ let RoomService = (() => {
             const member = loaded.state.members.find(entry => entry.name === request.name);
             if (member === undefined)
                 return { ok: false, error: { code: 'member-not-found' } };
+            const expected = loaded.state.runs.find(entry => entry.member === request.name && entry.state === 'running');
+            if ((request.expectedRunId !== undefined && expected?.runId !== request.expectedRunId)
+                || (request.expectedStartedAt !== undefined && expected?.startedAt !== request.expectedStartedAt)) {
+                return { ok: true, value: { cancelled: false } };
+            }
             const facade = probeLocalAgent(this.ctx);
-            const hit = facade !== undefined && member.childSessionId !== undefined
+            const native = member.kind === 'main-agent' && expected !== undefined ? this.ctx.agents.get(loaded.session.id) : undefined;
+            if (native !== undefined)
+                native.cancel({ kind: 'user' });
+            const hit = native !== undefined || (facade !== undefined && member.childSessionId !== undefined
                 ? facade.cancel(member.childSessionId)
-                : false;
+                : false);
             if (hit) {
                 const running = loaded.state.runs.find(entry => entry.member === request.name && entry.state === 'running');
                 if (running === undefined)
                     return { ok: true, value: { cancelled: true } };
                 loaded.session.append('room/run-state', {
                     member: request.name, state: 'cancelled', startedAt: running.startedAt,
+                    elapsedMs: Math.max(0, Date.now() - running.startedAt),
                     ...running.runId === undefined ? {} : { runId: running.runId },
                 });
                 // The engine's settle no-ops behind this edge, so the task closing the
@@ -1194,6 +1207,28 @@ let RoomService = (() => {
             }
             return { ok: true, value: { cancelled: false } };
         }
+        /** Native descendant controls share the host's continuation and cancellation channels. */
+        async cancelChild(request) {
+            const loaded = await this.ensureLive(request.sessionId);
+            if (!loaded.ok)
+                return { ok: false, error: loaded.error };
+            const target = this.ctx.sessions.get(request.childSessionId);
+            const seen = new Set([request.childSessionId]);
+            let parent = target?.header.parentSession;
+            while (parent !== undefined && parent !== request.sessionId && !seen.has(parent)) {
+                seen.add(parent);
+                parent = this.ctx.sessions.get(parent)?.header.parentSession;
+            }
+            if (!target || target.id === request.sessionId || parent !== request.sessionId)
+                return { ok: true, value: { cancelled: false } };
+            const facadeHit = probeLocalAgent(this.ctx)?.cancel(target.id) ?? false;
+            const agent = this.ctx.agents.get(target.id);
+            if (agent) {
+                this.ctx.get('subagents')?.interrupt(target.id, { kind: 'user', parentSessionId: target.header.parentSession });
+                agent.cancel({ kind: 'user' });
+            }
+            return { ok: true, value: { cancelled: facadeHit || agent !== undefined } };
+        }
     };
 })();
 export { RoomService };

package/lib/types/journal.d.ts

@@ -18,7 +18,7 @@ export declare const MAIN_AGENT_MEMBER = "dsh";
  * in-place add is that surface's temporary form — migrate to the official
  * one when it lands upstream.
  */
-export declare const ROOM_EVENT_TYPES: readonly ['room/created', 'room/plan-state', 'room/coordinator', 'room/delivery-state', 'room/member-added', 'room/member-updated', 'room/member-removed', 'room/dispatch', 'room/speech', 'room/run-state', 'room/relay', 'room/relay-resolved', 'room/task-added', 'room/task-updated', 'room/task-edited', 'room/goal'];
+export declare const ROOM_EVENT_TYPES: readonly ['room/created', 'room/plan-state', 'room/coordinator', 'room/delivery-state', 'room/member-added', 'room/member-updated', 'room/member-removed', 'room/dispatch', 'room/speech', 'room/run-state', 'room/execution-metadata', 'room/relay', 'room/relay-resolved', 'room/task-added', 'room/task-updated', 'room/task-edited', 'room/goal'];
 /** Whether an event log carries the room identity marker. */
 export declare function isRoomLog(events: readonly SessionEvent[]): boolean;
 /**