@khorsheed/dsh-room 0.2.2 → 0.2.4

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

@@ -6,7 +6,7 @@ import type { LocalAgentUi } from '@khorsheed/dsh-local-agent/client';
 import type { ReactNode } from 'react';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
-import type { RoomProviderList } from '../types.ts';
+import type { RoomProviderList, RoomQuestionAnswer, RoomRemoval, RoomSettings } from '../types.ts';
 import type { LocalAgentModelInfo, LocalAgentPromptResult } from '@khorsheed/dsh-local-agent/types';
 import type { RoomChromeVisibility } from './preset-visibility.ts';
 import type { RoomStore } from './room-store.ts';
@@ -17,23 +17,23 @@ export type RoomMutationOutcome = {
     readonly ok: false;
     readonly message: string;
 };
+/** A removal's outcome: what it did (for the undo line), or the failure copy. */
+export type RoomRemovalOutcome = {
+    readonly ok: true;
+    readonly value: RoomRemoval;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
 /** Injected action face of the session-header 邀请 agent action. */
 export type InviteAgentInjected = RoomInviteInjected;
 /** Full props of the 'conversation.session.header.actions' entry. */
 export type InviteAgentActionProps = PropsRuntime<'conversation.session.header.actions'> & InjectFace<InviteAgentInjected> & PropsLocale<'room'>;
-/** Injected face of the dock capsules (goal capsule + task capsule). */
-export interface RoomTasksInjected {
-    /** The client-side room state store (tasks and the goal ride the replayed state). */
+/** The room goal action (the task page's goal line). */
+export interface RoomGoalInjected {
+    /** The room store the views read. */
     readonly roomStore: RoomStore;
-    /** Add a pending task to a member's lane, optionally waiting on another member. */
-    readonly addTask: (member: string, title: string, blockedBy?: string) => Promise<RoomMutationOutcome>;
-    /**
-     * Close an open task. The status is the closing state: 'done' by default;
-     * the failed row's [关闭] passes 'cancelled' — the failure already speaks
-     * for itself, and a failed task must not count as goal progress.
-     */
-    readonly closeTask: (taskId: string, status?: 'done' | 'cancelled') => Promise<RoomMutationOutcome>;
-    /** Set (or, with a blank text, clear) the room's goal. */
+    /** Set (or, with a blank text, clear) the room goal. */
     readonly setGoal: (text: string) => Promise<RoomMutationOutcome>;
 }
 /**
@@ -48,8 +48,8 @@ export interface RoomInviteInjected {
     readonly roomCwd?: string | undefined;
     /** Invite a CLI member. */
     readonly invite: (values: RoomInviteValues) => Promise<RoomInviteOutcome>;
-    /** List the invitable providers (undefined on transport failure). */
-    readonly listProviders: () => Promise<RoomProviderList | undefined>;
+    /** List the invitable providers (undefined on transport failure); with a session, its mode rides along (`sessionPreset`). */
+    readonly listProviders: (sessionId?: SessionId) => Promise<RoomProviderList | undefined>;
     /**
      * Pick a member-level working directory through the official picker call
      * (`uiWorkspace.pickDirectory` on host 0.1.2 — the picker UI itself is not
@@ -149,28 +149,48 @@ export interface RoomModelDirectory {
 }
 /**
  * Injected face of the composer takeover entry: the dispatch submit plus the
- * task-board actions (sessionId binds at inject time), because the takeover
- * renders the task board itself — the `conversation.input.dock` seat rides
- * the hidden official fallback. The takeover also inherits the official bar's
+ * task capsule's entry to the task page and the composer's task tag
+ * (sessionId binds at inject time), because the takeover renders the dock
+ * itself — the `conversation.input.dock` seat rides the hidden official
+ * fallback. The takeover also inherits the official bar's
  * Stop duty: the fallback's Stop button hides with it, so `stop` re-homes the
  * main agent's turn cancel (the runtime session face's `cancel()`). The
- * invite share rides along for the fresh-room dock's invite capsule.
+ * invite share rides along for the fresh-room invite capsule.
  * `modelDirectory` is the official per-session model directory for the room's
  * own main agent (bare messages ARE its turns); undefined on a host without
  * 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;
+export interface RoomComposerInjected extends RoomGoalInjected, RoomInviteInjected {
+    /** Open the task page (at one task); absent without the right sidebar. */
+    readonly openTasks?: ((task?: string) => void) | undefined;
+    /** The composer's task tag store (see task-tag.ts). */
+    readonly taskTags?: import('./task-tag.ts').RoomTaskTags | 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, expectedRunId?: string) => void) | undefined;
+    /**
+     * Preview one draft chip through its owning trigger source (the official
+     * editor's chip-click gesture; a quote chip opens its full-text card).
+     * @returns whether a source accepted. Absent without the input-trigger service.
+     */
+    readonly openReference?: ((source: string, ref: string) => boolean) | undefined;
+    /**
+     * Other sessions for the @ menu: the host's session-reference candidates
+     * (the recent list merged with the query's own lookup), rooms flagged.
+     * Absent without the session-reference service.
+     */
+    readonly listSessions?: ((query: string, signal: AbortSignal) => Promise<readonly import('./at-menu.ts').SessionCandidate[]>) | undefined;
+    /**
+     * Insert the host's session chip for a picked session over a detect-coordinate span.
+     * @returns whether the input machine took it (false: the composer falls back to text).
+     */
+    readonly insertSessionReference?: ((candidate: import('./at-menu.ts').SessionCandidate, span: {
+        readonly start: number;
+        readonly end: number;
+        readonly draftRev: number;
+    }) => boolean) | undefined;
     /**
      * Dispatch a message into the room and refresh the store on success. EVERY
      * send routes here, bare text included (the host routes bare text to the
@@ -180,8 +200,10 @@ export interface RoomComposerInjected extends RoomTasksInjected, RoomInviteInjec
      * the dispatch engine runs in parallel). `targets` carries the
      * mention-menu picks (explicit addressing wherever the `@name` sits in
      * the sentence); the host unions them with the parsed leading tokens.
+     * `task` is the composer's tag (`new` or a task root id): it files the
+     * message under that task instead of letting dsh decide.
      */
-    readonly submit: (sessionId: SessionId, text: string, targets?: readonly string[]) => Promise<RoomMutationOutcome>;
+    readonly submit: (sessionId: SessionId, text: string, targets?: readonly string[], task?: string) => Promise<RoomMutationOutcome>;
     /** Interrupt the room's own main-agent turn (the hidden official bar's Stop). */
     readonly stop: () => void;
     /**
@@ -206,12 +228,20 @@ export type MembersViewProps = PropsRuntime<'conversation.view'> & InjectFace<Ro
 export interface RoomInviteValues {
     readonly provider: string;
     readonly name: string;
+    /** Short public role (omitted = none). */
+    readonly role?: string;
+    /** `native`: a DSH child agent in this host (omitted = a CLI member). */
+    readonly kind?: 'cli' | 'native';
+    /** Native only: the host agent preset (omitted = the host default). */
+    readonly preset?: string;
     readonly instructions?: string;
     /** Member-level working directory (omitted = inherits the room session's cwd). */
     readonly cwd?: string;
     readonly firstTask?: string;
     /** The delegation's invite-time model (omitted = follow the harness default). */
     readonly model?: string;
+    /** The delegation's invite-time reasoning effort (omitted = follow the harness default). */
+    readonly effort?: string;
 }
 /** The invite outcome: the receipt's pendingFirstTask picks the success copy. */
 export type RoomInviteOutcome = {
@@ -230,7 +260,15 @@ export interface RoomMembersInjected extends RoomInviteInjected {
     readonly openSession: (sessionId: SessionId) => void;
     /** Remove the named member from the roster. */
     readonly setCoordinator?: ((memberId: string, expectedRevision: number) => Promise<RoomMutationOutcome>) | undefined;
-    readonly removeMember: (member: string) => Promise<RoomMutationOutcome>;
+    readonly removeMember: (member: string) => Promise<RoomRemovalOutcome>;
+    /** Undo a removal: the member rejoins on its own session. */
+    readonly restoreMember: (member: string) => Promise<RoomMutationOutcome>;
+    /** Open the team page in the right sidebar, optionally revealing one member. Absent without a sidebar. */
+    readonly openTeam?: ((member?: string) => void) | undefined;
+    /** Take an outside session off the member list (its own session is untouched). */
+    readonly unlinkSession?: ((target: string) => void) | undefined;
+    /** Change the room's collaboration settings. */
+    readonly setSettings: (patch: Partial<RoomSettings>) => Promise<RoomMutationOutcome>;
     /**
      * Edit the named member: rename, cwd override (null clears back to
      * inheriting the room cwd), role instructions (null clears them), intended
@@ -265,10 +303,14 @@ export interface RoomMemberPatch {
     readonly rename?: string;
     /** New role instructions; null clears them. */
     readonly instructions?: string | null;
+    /** New public role; null clears it. */
+    readonly role?: string | null;
     /** New cwd override; null clears back to inheriting the room cwd. */
     readonly cwd?: string | null;
     /** New intended model; null clears back to the harness default. */
     readonly model?: string | null;
+    /** New intended reasoning effort; null clears back to the harness default. */
+    readonly effort?: string | null;
 }
 /** Injected face of the member-speech chat node. */
 export interface RoomSpeechInjected {
@@ -276,6 +318,11 @@ export interface RoomSpeechInjected {
     readonly roomStore: RoomStore;
     /** Open a session (the speech's child-session jump). */
     readonly openSession: (sessionId: SessionId) => void;
+    /**
+     * Open Context Lens at the member's round (its session + closing message);
+     * absent when the composition has no Context Lens.
+     */
+    readonly openDetail?: ((sessionId: SessionId, messageId: string) => void) | undefined;
 }
 /** Full props of the 'room-speech' chat-node renderer. */
 export type RoomSpeechViewProps = PropsRuntime<'conversation.chat.node', 'room-speech'> & InjectFace<RoomSpeechInjected> & PropsLocale<'room'>;
@@ -304,24 +351,47 @@ export interface RoomRelayInjected {
 }
 /** Full props of the 'room-relay' chat-node renderer. */
 export type RoomRelayViewProps = PropsRuntime<'conversation.chat.node', 'room-relay'> & InjectFace<RoomRelayInjected> & PropsLocale<'room'>;
-/** Injected face of the task-advance chat node. */
-export interface RoomTaskLineInjected {
-    /** The client-side room state store (the goal-progress suffix). */
-    readonly roomStore: RoomStore;
+/** Injected face of a member's tool approval line. */
+export interface RoomApprovalInjected {
+    /** Answer the approval (allow once / reject); resolves with an error message when it already ended. */
+    readonly answerApproval: (approvalId: string, outcome: 'allowed-once' | 'rejected') => Promise<string | undefined>;
 }
-/** Full props of the 'room-task-line' chat-node renderer. */
-export type RoomTaskLineViewProps = PropsRuntime<'conversation.chat.node', 'room-task-line'> & InjectFace<RoomTaskLineInjected> & PropsLocale<'room'>;
-/**
- * Props of the dock capsules (goal capsule + task capsule), rendered by the
- * RoomComposer itself above the input card — NOT a slot entry:
- * `conversation.input.dock` lives inside the official composer fallback,
- * which the takeover hides. The invite share serves the fresh-room state:
- * a room with neither a goal nor any task renders a single 「＋ 邀请成员」
- * capsule instead of the pair, opening the invite dialog straight from the
- * dock.
- */
-export type RoomDockCapsulesProps = {
-    readonly sessionId: SessionId;
-    readonly formalPlans?: boolean;
-} & RoomTasksInjected & RoomInviteInjected & PropsLocale<'room'>;
+/** Injected face of a room decision row. */
+export interface RoomDecisionInjected {
+    /** Open Context Lens at this decision's model request; absent without Context Lens. */
+    readonly openDecision?: ((decisionId: string) => void) | undefined;
+}
+/** Full props of the 'room-decision' chat-node renderer. */
+export type RoomDecisionViewProps = PropsRuntime<'conversation.chat.node', 'room-decision'> & InjectFace<RoomDecisionInjected> & PropsLocale<'room'>;
+/** Injected face of a member's question card. */
+export interface RoomQuestionInjected {
+    /** Submit the answers; resolves with an error message when the card already ended. */
+    readonly answerQuestion: (questionId: string, answers: readonly RoomQuestionAnswer[]) => Promise<string | undefined>;
+}
+/** Full props of the 'room-question' chat-node renderer. */
+export type RoomQuestionViewProps = PropsRuntime<'conversation.chat.node', 'room-question'> & InjectFace<RoomQuestionInjected> & PropsLocale<'room'>;
+/** Injected face of the help rows (the asking room's thread row, the helper's request card). */
+export interface RoomHelpInjected {
+    /** Open another session (the helper's, or the asking room). */
+    readonly openSession: (sessionId: SessionId) => void;
+    /** Keep an outside session on the member list (the third ask's hint). */
+    readonly linkSession?: ((target: string, title: string) => void) | undefined;
+    /** Dismiss that hint for good. */
+    readonly dismissNudge?: ((target: string) => void) | undefined;
+    /** The client-side room state store (the reminder setting). */
+    readonly roomStore?: RoomStore | undefined;
+}
+/** Full props of the 'room-help' chat-node renderer. */
+export type RoomHelpViewProps = PropsRuntime<'conversation.chat.node', 'room-help'> & InjectFace<RoomHelpInjected> & PropsLocale<'room'>;
+/** Full props of the 'room-help-request' chat-node renderer. */
+export type RoomHelpRequestViewProps = PropsRuntime<'conversation.chat.node', 'room-help-request'> & InjectFace<RoomHelpInjected> & PropsLocale<'room'>;
+/** Full props of the 'room-approval' chat-node renderer. */
+export type RoomApprovalViewProps = PropsRuntime<'conversation.chat.node', 'room-approval'> & InjectFace<RoomApprovalInjected> & PropsLocale<'room'>;
+/** Injected face of the held-reports line. */
+export interface RoomInboxInjected {
+    /** Hand the named member its held reports now. */
+    readonly releaseReports: (member: string) => Promise<void>;
+}
+/** Full props of the 'room-inbox' chat-node renderer. */
+export type RoomInboxViewProps = PropsRuntime<'conversation.chat.node', 'room-inbox'> & InjectFace<RoomInboxInjected> & PropsLocale<'room'>;
 //# sourceMappingURL=slots.d.ts.map

package/lib/types/client/task-tag.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The composer's task tag, per room session: the task page's 「追问」 and
+ * 「＋ 新任务」 put a removable 「任务 N」 / 「新任务」 chip on the main
+ * composer (the page has no input of its own), the next send carries it as
+ * postMessage's `task`, and removing the chip leaves the filing to dsh.
+ * Every set bumps a revision so the composer takes focus even when the
+ * same tag is set twice.
+ */
+/** A tag on the composer. */
+export interface RoomTaskTag {
+    /** `new`, or the task's root id. */
+    readonly task: string;
+    /** The chip text (「任务 3」 / 「新任务」). */
+    readonly label: string;
+    readonly revision: number;
+}
+/** The shared tag store; one per client plugin. */
+export declare class RoomTaskTags {
+    private readonly tags;
+    private readonly listeners;
+    private revision;
+    /** Subscribe to tag changes (useSyncExternalStore shape). */
+    readonly subscribe: (listener: () => void) => (() => void);
+    /** The session's current tag. */
+    readonly get: (sessionId: string) => RoomTaskTag | undefined;
+    /** Put a tag on the session's composer, or clear it. */
+    set(sessionId: string, tag: {
+        readonly task: string;
+        readonly label: string;
+    } | undefined): void;
+}
+//# sourceMappingURL=task-tag.d.ts.map

package/lib/types/client/task-tag.js

@@ -0,0 +1,33 @@
+/**
+ * The composer's task tag, per room session: the task page's 「追问」 and
+ * 「＋ 新任务」 put a removable 「任务 N」 / 「新任务」 chip on the main
+ * composer (the page has no input of its own), the next send carries it as
+ * postMessage's `task`, and removing the chip leaves the filing to dsh.
+ * Every set bumps a revision so the composer takes focus even when the
+ * same tag is set twice.
+ */
+/** The shared tag store; one per client plugin. */
+export class RoomTaskTags {
+    tags = new Map();
+    listeners = new Set();
+    revision = 0;
+    /** Subscribe to tag changes (useSyncExternalStore shape). */
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    };
+    /** The session's current tag. */
+    get = (sessionId) => this.tags.get(sessionId);
+    /** Put a tag on the session's composer, or clear it. */
+    set(sessionId, tag) {
+        if (tag === undefined) {
+            if (!this.tags.delete(sessionId))
+                return;
+        }
+        else {
+            this.tags.set(sessionId, { ...tag, revision: ++this.revision });
+        }
+        for (const listener of this.listeners)
+            listener();
+    }
+}

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

@@ -0,0 +1,50 @@
+/**
+ * Pure projections the task page and the composer's task capsule share:
+ * which tasks need the human, a task's subtask tree (who handed what to
+ * whom, from each delivery's `parent`), and the time segments its rows and
+ * swimlanes draw.
+ */
+import type { RoomDelivery, RoomJob, RoomRelay, RoomState } from '../types.ts';
+/** One stretch of a delivery's life on the timeline. */
+export interface TaskSegment {
+    /** queue = waiting to start, held = a finished report waiting to be handed over, exec = running. */
+    readonly kind: 'queue' | 'held' | 'exec';
+    readonly from: number;
+    readonly to: number;
+}
+/** A delivery placed in its task's tree. */
+export interface SubtaskNode {
+    readonly delivery: RoomDelivery;
+    readonly children: readonly SubtaskNode[];
+}
+/** The list filters, in order. */
+export declare const TASK_FILTERS: readonly ['running', 'attention', 'done', 'all'];
+export type TaskFilter = typeof TASK_FILTERS[number];
+/** Completed tasks shown by default; older ones stay in the log. */
+export declare const DONE_SHOWN = 20;
+/** Whether a delivery is still open (queued, running or a held report). */
+export declare function isOpenDelivery(row: RoomDelivery): boolean;
+/** Relays waiting for the human's confirmation. */
+export declare function pendingRelays(state: RoomState): readonly RoomRelay[];
+/** How many things wait on the human: deliveries with an unknown outcome, held relays, and members' tool approvals. */
+export declare function attentionCount(state: RoomState): number;
+/** Whether a task needs the human: an uncertain delivery, or a relay held inside it. */
+export declare function needsAttention(state: RoomState, job: RoomJob): boolean;
+/** The tasks a filter shows (`running` includes those needing attention, as both are open). */
+export declare function filterJobs(state: RoomState, filter: TaskFilter): readonly RoomJob[];
+/** A task's deliveries, in dispatch order. */
+export declare function jobDeliveries(state: RoomState, job: RoomJob): readonly RoomDelivery[];
+/**
+ * The task's subtask tree: work handed out (reports travel back up the tree
+ * and are not nodes), each delivery under the delivery whose round sent it.
+ * A delivery whose sender is outside the task — the human, or a round of
+ * another task — is a root.
+ */
+export declare function subtaskTree(state: RoomState, job: RoomJob): readonly SubtaskNode[];
+/** A delivery's time segments up to `now` for the open edges. */
+export declare function segmentsOf(row: RoomDelivery, now: number): readonly TaskSegment[];
+/** How long a task has taken: to its last settlement, or until now while open. */
+export declare function jobElapsed(job: RoomJob, now: number): number;
+/** The members still working on a task (running), by id, in first-start order. */
+export declare function runningMembers(state: RoomState, job: RoomJob): readonly string[];
+//# sourceMappingURL=tasks.d.ts.map

package/lib/types/client/tasks.js

@@ -0,0 +1,82 @@
+/** The list filters, in order. */
+export const TASK_FILTERS = ['running', 'attention', 'done', 'all'];
+/** Completed tasks shown by default; older ones stay in the log. */
+export const DONE_SHOWN = 20;
+const OPEN = new Set(['queued', 'running', 'held']);
+/** Whether a delivery is still open (queued, running or a held report). */
+export function isOpenDelivery(row) {
+    return OPEN.has(row.status);
+}
+/** Relays waiting for the human's confirmation. */
+export function pendingRelays(state) {
+    return state.relays.filter(relay => relay.state === 'pending');
+}
+/** How many things wait on the human: deliveries with an unknown outcome, held relays, and members' tool approvals. */
+export function attentionCount(state) {
+    return (state.deliveries ?? []).filter(row => row.status === 'uncertain').length + pendingRelays(state).length + (state.approvals?.length ?? 0) + (state.questions?.length ?? 0);
+}
+/** Whether a task needs the human: an uncertain delivery, or a relay held inside it. */
+export function needsAttention(state, job) {
+    return job.status === 'attention' || pendingRelays(state).some(relay => relay.intent?.task === job.id);
+}
+/** The tasks a filter shows (`running` includes those needing attention, as both are open). */
+export function filterJobs(state, filter) {
+    const jobs = state.jobs ?? [];
+    switch (filter) {
+        case 'running': return jobs.filter(job => job.status === 'running' || needsAttention(state, job));
+        case 'attention': return jobs.filter(job => needsAttention(state, job));
+        case 'done': return jobs.filter(job => job.status === 'done' || job.status === 'stopped').slice(0, DONE_SHOWN);
+        case 'all': return jobs.slice(0, DONE_SHOWN + jobs.filter(job => job.status !== 'done' && job.status !== 'stopped').length);
+    }
+}
+/** A task's deliveries, in dispatch order. */
+export function jobDeliveries(state, job) {
+    const ids = new Set(job.deliveries);
+    return (state.deliveries ?? []).filter(row => ids.has(row.id));
+}
+/**
+ * The task's subtask tree: work handed out (reports travel back up the tree
+ * and are not nodes), each delivery under the delivery whose round sent it.
+ * A delivery whose sender is outside the task — the human, or a round of
+ * another task — is a root.
+ */
+export function subtaskTree(state, job) {
+    const rows = jobDeliveries(state, job).filter(row => row.origin !== 'report');
+    const ids = new Set(rows.map(row => row.id));
+    const children = new Map();
+    for (const row of rows) {
+        const parent = row.parent !== undefined && ids.has(row.parent) ? row.parent : undefined;
+        children.set(parent, [...children.get(parent) ?? [], row]);
+    }
+    const build = (parent, seen) => (children.get(parent) ?? []).filter(row => !seen.has(row.id))
+        .map(row => ({ delivery: row, children: build(row.id, new Set([...seen, row.id])) }));
+    return build(undefined, new Set());
+}
+/** A delivery's time segments up to `now` for the open edges. */
+export function segmentsOf(row, now) {
+    const segments = [];
+    const end = row.endedAt ?? (isOpenDelivery(row) ? now : row.startedAt ?? row.queuedAt);
+    const started = row.startedAt ?? (row.status === 'queued' || row.status === 'held' ? now : end);
+    if (row.heldAt !== undefined) {
+        const released = row.releasedAt ?? Math.min(started, now);
+        if (row.heldAt > row.queuedAt)
+            segments.push({ kind: 'queue', from: row.queuedAt, to: row.heldAt });
+        segments.push({ kind: 'held', from: row.heldAt, to: released });
+        if (started > released)
+            segments.push({ kind: 'queue', from: released, to: started });
+    }
+    else if (started > row.queuedAt) {
+        segments.push({ kind: 'queue', from: row.queuedAt, to: started });
+    }
+    if (row.startedAt !== undefined && end > row.startedAt)
+        segments.push({ kind: 'exec', from: row.startedAt, to: end });
+    return segments;
+}
+/** How long a task has taken: to its last settlement, or until now while open. */
+export function jobElapsed(job, now) {
+    return Math.max(0, (job.endedAt ?? now) - job.startedAt);
+}
+/** The members still working on a task (running), by id, in first-start order. */
+export function runningMembers(state, job) {
+    return [...new Set(jobDeliveries(state, job).filter(row => row.status === 'running').map(row => row.memberId))];
+}

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

@@ -0,0 +1,73 @@
+import type { RoomDelivery, RoomHelp, RoomMember, RoomState } from '../types.ts';
+/** The human, as a tree root. */
+export declare const TEAM_ROOT = "you";
+/** One delivery a member received. */
+export interface TeamDelivery {
+    readonly id: string;
+    readonly seq: number;
+    /** Sender name, or {@link TEAM_ROOT} for the human. */
+    readonly from: string;
+    readonly text: string;
+    readonly status: RoomDelivery['status'];
+    readonly kind: 'task' | 'notify' | 'report';
+}
+/** One member node. */
+export interface TeamNode {
+    /** Member id (name for legacy members without one). */
+    readonly id: string;
+    readonly member: RoomMember;
+    /** Parent node id, or {@link TEAM_ROOT}. */
+    readonly parent: string;
+    readonly coordinator: boolean;
+    readonly status: 'running' | 'idle' | 'failed';
+    /** The running delivery's task title, when running. */
+    readonly current?: string;
+    readonly model?: string;
+    readonly tokens: number;
+    readonly elapsedMs: number;
+    readonly rounds: number;
+    /** Newest first. */
+    readonly deliveries: readonly TeamDelivery[];
+    /** An outside session: asked for help (and/or kept on the member list). */
+    readonly external?: {
+        readonly sessionId: string;
+        /** On the member list (「加入房间成员」). */
+        readonly linked: boolean;
+        /** A room target (asked through that room's roster): never linkable. */
+        readonly room: boolean;
+        /** Every ask has ended (replied or failed). */
+        readonly done: boolean;
+        readonly helps: readonly RoomHelp[];
+    };
+}
+/** What flowed from one node to another. */
+export interface TeamEdge {
+    readonly from: string;
+    readonly to: string;
+    readonly tasks: number;
+    readonly reports: number;
+    readonly notifies: number;
+}
+/** The whole projection. */
+export interface Team {
+    readonly nodes: readonly TeamNode[];
+    readonly edges: readonly TeamEdge[];
+    readonly totals: {
+        readonly members: number;
+        readonly running: number;
+        readonly deliveries: number;
+        readonly tokens: number;
+        readonly elapsedMs: number;
+    };
+}
+/**
+ * Project the room state into the team tree.
+ * @param state - the replayed room state.
+ * @returns nodes in tree order (parents before children), edges and totals.
+ */
+export declare function teamOf(state: RoomState): Team;
+/** The id of an outside session's node. */
+export declare const externalId: (sessionId: string, member?: string) => string;
+/** Compact token count: 1.2M / 288k / 512. */
+export declare function formatTokens(tokens: number): string;
+//# sourceMappingURL=team.d.ts.map