@wowyuarm/dsh-agent-team 0.1.0

package/packages/client-agent-team/lib/types/client/TeamThreadPage.js

@@ -0,0 +1,464 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment, useEffect, useMemo, useRef, useState } from 'react';
+import { Button, DisclosureRow, IconChevronLeftOutline14, IconChecklistOutline14, Pill } from '@deepseek-ai/dsh-client-ui-primitives';
+import { TeamComposer } from "./TeamComposer.js";
+import { TeamPresenceDot } from "./TeamPresenceDot.js";
+import { TeamMessage } from "./TeamMessage.js";
+import { formatActivity, formatClaimState, formatTaskStatus, formatTaskTitle, mentionNamesOf } from "./team-formatters.js";
+import { daySeparatorLabel, timelineDayKey } from "./team-separators.js";
+import { useTimelineScroll } from "./timeline-scroll.js";
+import css from './conversation.module.css';
+import threadCss from './thread.module.css';
+function factKey(fact) {
+    return fact.kind === 'message' ? `message:${fact.message.messageRef}` : `activity:${fact.activity.activityRef}`;
+}
+function messageFact(message, mentions = []) {
+    return { kind: 'message', sequence: message.sequence, message, mentions };
+}
+function mergeFacts(...groups) {
+    const byKey = new Map();
+    for (const group of groups)
+        for (const fact of group)
+            byKey.set(factKey(fact), fact);
+    return [...byKey.values()].sort((left, right) => left.sequence - right.sequence);
+}
+function minSequence(facts) {
+    return facts.reduce((minimum, fact) => minimum === undefined ? fact.sequence : Math.min(minimum, fact.sequence), undefined);
+}
+function readMeta(facts) {
+    return new Map(facts.map(fact => [factKey(fact.fact), fact]));
+}
+export function TeamThreadPage(props) {
+    const { workspaceId, channelRef, taskRef, threadRef, taskNumber, backToWorkspace, loadChannels, readThread, loadThreadHistory, subscribeChanges, loadMembers, reply, changeTask, t, } = props;
+    const [projection, setProjection] = useState();
+    const [channelView, setChannelView] = useState();
+    const [members, setMembers] = useState([]);
+    const [currentFacts, setCurrentFacts] = useState([]);
+    const [olderFacts, setOlderFacts] = useState([]);
+    const [readFacts, setReadFacts] = useState([]);
+    const [historyCursor, setHistoryCursor] = useState();
+    const [historyHasMore, setHistoryHasMore] = useState(false);
+    const [remainingUnreadCount, setRemainingUnreadCount] = useState(0);
+    const [newFactsCount, setNewFactsCount] = useState(0);
+    const [draft, setDraft] = useState('');
+    const [recipients, setRecipients] = useState(new Set());
+    const [claimsOpen, setClaimsOpen] = useState(false);
+    const [replyRequestId, setReplyRequestId] = useState();
+    const [confirmation, setConfirmation] = useState();
+    const [statusMessage, setStatusMessage] = useState();
+    const [pending, setPending] = useState(false);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState();
+    const mountedRef = useRef(false);
+    const currentFactsRef = useRef([]);
+    const sequenceRef = useRef(0);
+    const readRequestIdRef = useRef(crypto.randomUUID());
+    const mutationRequests = useRef(new Map());
+    const threadLastFact = currentFacts[currentFacts.length - 1];
+    const timeline = useTimelineScroll(`${currentFacts.length}:${olderFacts.length}:${threadLastFact === undefined ? '' : factKey(threadLastFact)}`);
+    const updateProjection = (next) => {
+        setProjection(next);
+        setReadFacts(next.facts);
+        setRemainingUnreadCount(next.remainingUnreadCount);
+        const anchor = messageFact(next.anchor, next.anchorMentions);
+        const batch = [anchor, ...next.facts.map(fact => fact.fact)];
+        setCurrentFacts(current => {
+            const merged = mergeFacts(current, batch);
+            currentFactsRef.current = merged;
+            return merged;
+        });
+        setNewFactsCount(0);
+    };
+    const readCurrent = async (newRequest = false) => {
+        if (!mountedRef.current)
+            return false;
+        if (newRequest)
+            readRequestIdRef.current = crypto.randomUUID();
+        const sequence = sequenceRef.current + 1;
+        sequenceRef.current = sequence;
+        setLoading(true);
+        try {
+            const result = await readThread({ requestId: readRequestIdRef.current, workspaceId, taskRef });
+            if (!mountedRef.current || sequence !== sequenceRef.current)
+                return false;
+            if (!result.ok) {
+                setError(result.error.message);
+                return false;
+            }
+            updateProjection(result.value);
+            setError(undefined);
+            return true;
+        }
+        catch (cause) {
+            if (mountedRef.current && sequence === sequenceRef.current)
+                setError(cause instanceof Error ? cause.message : String(cause));
+            return false;
+        }
+        finally {
+            if (mountedRef.current && sequence === sequenceRef.current)
+                setLoading(false);
+        }
+    };
+    const refreshSupplemental = async () => {
+        try {
+            const [loadedMembers, loadedView] = await Promise.all([
+                loadMembers({ workspaceId }),
+                loadChannels({ workspaceId, ...(channelRef === undefined ? {} : { channelRef }), threadRef, includeActivities: false, limit: 1 }),
+            ]);
+            if (!mountedRef.current)
+                return;
+            if (loadedMembers.ok)
+                setMembers(loadedMembers.value);
+            if (loadedView.ok)
+                setChannelView(loadedView.value);
+            const failure = [loadedMembers, loadedView].find(result => !result.ok);
+            if (failure !== undefined && !failure.ok)
+                setError(failure.error.message);
+        }
+        catch (cause) {
+            if (mountedRef.current)
+                setError(cause instanceof Error ? cause.message : String(cause));
+        }
+    };
+    const refreshPassiveFacts = async () => {
+        try {
+            const result = await loadThreadHistory({ workspaceId, taskRef, limit: 100 });
+            if (!mountedRef.current || !result.ok)
+                return;
+            const incoming = result.value.facts;
+            const shown = currentFactsRef.current;
+            if (shown.length === 0)
+                return;
+            const known = new Set(shown.map(fact => factKey(fact)));
+            // Facts older than everything already rendered are backfill of the
+            // wider history window this fetch uses, not new updates; counting
+            // them would re-flag already-read messages after every change wake.
+            const newestShown = shown.reduce((maximum, fact) => Math.max(maximum, fact.sequence), 0);
+            const additions = incoming.filter(fact => !known.has(factKey(fact)) && fact.sequence > newestShown);
+            setCurrentFacts(current => {
+                const merged = mergeFacts(current, incoming);
+                currentFactsRef.current = merged;
+                return merged;
+            });
+            setProjection(current => current === undefined ? current : { ...current, task: result.value.task, thread: result.value.thread, claims: result.value.claims });
+            if (additions.length === 0)
+                return;
+            // A reader scrolled away from the tail must be offered the explicit
+            // new-updates action; a reader pinned to the bottom is watching these
+            // facts arrive, so they are already seen and the batch is acknowledged
+            // durably instead of being counted for an explicit read.
+            if (!timeline.isPinned()) {
+                setNewFactsCount(current => current + additions.length);
+                return;
+            }
+            const priorSequence = sequenceRef.current;
+            if (await readCurrent(true))
+                return;
+            // The durable acknowledgment did not happen (it failed, a newer read
+            // superseded it, or the page unmounted); fall back to the explicit
+            // action unless that newer read now owns the tail.
+            if (!mountedRef.current || sequenceRef.current !== priorSequence + 1)
+                return;
+            setNewFactsCount(current => current + additions.length);
+        }
+        catch {
+            // A passive refresh is an invalidation convenience; the next explicit action rereads Host state.
+        }
+    };
+    useEffect(() => {
+        mountedRef.current = true;
+        setProjection(undefined);
+        setChannelView(undefined);
+        setMembers([]);
+        setCurrentFacts([]);
+        currentFactsRef.current = [];
+        setOlderFacts([]);
+        setReadFacts([]);
+        setHistoryCursor(undefined);
+        setHistoryHasMore(false);
+        setRemainingUnreadCount(0);
+        setNewFactsCount(0);
+        setError(undefined);
+        setStatusMessage(undefined);
+        const sequence = sequenceRef.current + 1;
+        sequenceRef.current = sequence;
+        setLoading(true);
+        void (async () => {
+            // One parallel round covers the whole first paint. The durable read no
+            // longer wakes any change scope, so no second wave follows it.
+            const [read, history] = await Promise.all([
+                readThread({ requestId: readRequestIdRef.current, workspaceId, taskRef }),
+                loadThreadHistory({ workspaceId, taskRef, limit: 20 }).catch(() => undefined),
+            ]);
+            if (!mountedRef.current || sequence !== sequenceRef.current)
+                return;
+            if (!read.ok) {
+                setError(read.error.message);
+                setLoading(false);
+                return;
+            }
+            updateProjection(read.value);
+            // Opened onto unread updates: land on the boundary instead of the floor.
+            if (read.value.facts.some(fact => fact.unread))
+                timeline.jumpToBoundary();
+            if (history !== undefined && history.ok) {
+                setCurrentFacts(current => {
+                    const merged = mergeFacts(current, history.value.facts);
+                    currentFactsRef.current = merged;
+                    return merged;
+                });
+                setHistoryCursor(history.value.cursor);
+                setHistoryHasMore(history.value.hasMore);
+            }
+            setError(undefined);
+            setLoading(false);
+        })();
+        void refreshSupplemental();
+        const disposers = [
+            subscribeChanges({ kind: 'thread', threadRef }, update => {
+                if (!mountedRef.current)
+                    return;
+                if (update.type === 'failed') {
+                    setError(update.message);
+                    return;
+                }
+                void refreshPassiveFacts();
+            }),
+            subscribeChanges({ kind: 'workspace', workspaceId }, update => {
+                if (!mountedRef.current)
+                    return;
+                if (update.type === 'failed') {
+                    setError(update.message);
+                    return;
+                }
+                void refreshSupplemental();
+            }),
+        ];
+        return () => {
+            mountedRef.current = false;
+            sequenceRef.current += 1;
+            for (const dispose of disposers)
+                dispose();
+        };
+    }, [workspaceId, taskRef, threadRef]);
+    const loadOlder = async () => {
+        if (historyHasMore === false && historyCursor === undefined)
+            return;
+        const beforeSequence = historyCursor ?? minSequence(currentFactsRef.current);
+        if (beforeSequence === undefined)
+            return;
+        setLoading(true);
+        try {
+            const result = await loadThreadHistory({ workspaceId, taskRef, beforeSequence, limit: 20 });
+            if (!mountedRef.current)
+                return;
+            if (!result.ok) {
+                setError(result.error.message);
+                return;
+            }
+            setOlderFacts(current => mergeFacts(current, result.value.facts));
+            setHistoryCursor(result.value.cursor);
+            setHistoryHasMore(result.value.hasMore);
+            setError(undefined);
+        }
+        catch (cause) {
+            if (mountedRef.current)
+                setError(cause instanceof Error ? cause.message : String(cause));
+        }
+        finally {
+            if (mountedRef.current)
+                setLoading(false);
+        }
+    };
+    const activeProjection = projection;
+    const task = activeProjection?.task;
+    const thread = activeProjection?.thread;
+    const taskTitle = activeProjection === undefined ? undefined : formatTaskTitle(activeProjection.anchor.body);
+    const taskClaims = activeProjection?.claims ?? [];
+    const effectiveChannelRef = task?.channelRef ?? channelRef;
+    const channelMemberIds = useMemo(() => new Set(channelView?.members.filter(item => item.channelRef === effectiveChannelRef).map(item => item.memberId) ?? []), [channelView, effectiveChannelRef]);
+    const channelMembers = members.filter(status => channelMemberIds.size === 0 || channelMemberIds.has(status.member.memberId));
+    const mentionHandlesMap = useMemo(() => new Map(members.map(status => [status.member.memberId, status.member.handle.replace(/^@/, '')])), [members]);
+    const metadata = useMemo(() => readMeta(readFacts), [readFacts]);
+    const unreadIndex = useMemo(() => {
+        const all = mergeFacts([messageFact(activeProjection?.anchor ?? { messageRef: 'missing', sequence: 0 }, activeProjection?.anchorMentions), ...readFacts.map(fact => fact.fact), ...currentFacts]);
+        return all.findIndex(fact => metadata.get(factKey(fact))?.unread === true);
+    }, [activeProjection?.anchor, readFacts, currentFacts, metadata]);
+    const memberName = (memberId) => {
+        if (memberId === channelView?.humanMemberId)
+            return t('human');
+        const status = members.find(candidate => candidate.member.memberId === memberId);
+        return status === undefined ? t('memberUnknown') : `@${status.member.handle}`;
+    };
+    const messageSender = (fact) => fact.kind === 'message' ? fact.message.sender : undefined;
+    const renderFact = (fact, grouped = false) => {
+        if (fact.kind === 'message') {
+            const sender = memberName(fact.message.sender);
+            const senderStatus = members.find(candidate => candidate.member.memberId === fact.message.sender);
+            return _jsx(TeamMessage, { senderName: sender, memberId: fact.message.sender, human: fact.message.sender === channelView?.humanMemberId, body: fact.message.body, occurredAt: fact.message.occurredAt, mentionNames: mentionNamesOf(fact.mentions, mentionHandlesMap), grouped: grouped, ...(senderStatus === undefined ? {} : { senderTitle: senderStatus.member.description }) }, factKey(fact));
+        }
+        return _jsxs("p", { className: threadCss.activityRow, children: [_jsx("span", { className: threadCss.activityMark, "aria-hidden": "true" }), _jsx("span", { className: threadCss.activityText, children: formatActivity(fact.activity, { t, actorName: memberName, claims: taskClaims }) })] }, factKey(fact));
+    };
+    /** One run = one same-sender reply turn; activities, the unread boundary, and day changes break runs. */
+    const renderFactBlocks = (facts, boundaryIndex) => {
+        const nodes = [];
+        let run = [];
+        let lastDay;
+        const flushRun = () => {
+            if (run.length > 0)
+                nodes.push(_jsx("div", { className: css.messageRun, children: run.map((entry, entryIndex) => renderFact(entry, entryIndex > 0)) }, `run-${factKey(run[0])}`));
+            run = [];
+        };
+        facts.forEach((fact, index) => {
+            const occurredAt = fact.kind === 'message' ? fact.message.occurredAt : undefined;
+            if (occurredAt !== undefined) {
+                const day = timelineDayKey(occurredAt);
+                if (lastDay !== undefined && day !== lastDay) {
+                    flushRun();
+                    nodes.push(_jsx("p", { className: threadCss.daySeparator, children: _jsx("span", { children: daySeparatorLabel(occurredAt) }) }, `day-${index}`));
+                }
+                lastDay = day;
+            }
+            const sender = messageSender(fact);
+            if (sender !== undefined && run.length > 0 && sender === messageSender(run[run.length - 1])) {
+                run.push(fact);
+                return;
+            }
+            flushRun();
+            if (boundaryIndex === index)
+                nodes.push(_jsx("p", { className: threadCss.unreadBoundary, role: "separator", "data-thread-boundary": true, children: _jsx("span", { children: t('unreadBoundary') }) }, `boundary-${index}`));
+            if (sender !== undefined)
+                run.push(fact);
+            else
+                nodes.push(_jsx(Fragment, { children: renderFact(fact) }, factKey(fact)));
+        });
+        flushRun();
+        return nodes;
+    };
+    const refreshAfterFence = async () => {
+        timeline.jumpToLatest();
+        await readCurrent(true);
+        await refreshSupplemental();
+    };
+    const mutateTask = async (action) => {
+        if (pending || task === undefined || thread === undefined)
+            return;
+        setPending(true);
+        setError(undefined);
+        const key = `task:${action}`;
+        const requestId = mutationRequests.current.get(key) ?? crypto.randomUUID();
+        mutationRequests.current.set(key, requestId);
+        try {
+            const result = await changeTask({ requestId, workspaceId, taskRef: task.taskRef, action, baseRevision: thread.revision });
+            if (!result.ok) {
+                setError(result.error.message);
+                return;
+            }
+            if (result.value.kind === 'committed') {
+                mutationRequests.current.delete(key);
+                const committed = result.value;
+                setProjection(current => current === undefined ? current : { ...current, task: committed.task, thread: committed.thread, claims: committed.claims });
+                setCurrentFacts(current => {
+                    const merged = mergeFacts(current, [{ kind: 'activity', sequence: committed.activity.sequence, activity: committed.activity }]);
+                    currentFactsRef.current = merged;
+                    return merged;
+                });
+                await readCurrent(true);
+                await refreshSupplemental();
+            }
+            else if (result.value.kind === 'unread_required') {
+                setError(t('unreadRequired', { count: result.value.unreadCount }));
+                mutationRequests.current.delete(key);
+                await refreshAfterFence();
+            }
+            else {
+                setError(t('staleRevision'));
+                mutationRequests.current.delete(key);
+                await refreshPassiveFacts();
+            }
+        }
+        catch (cause) {
+            setError(cause instanceof Error ? cause.message : String(cause));
+        }
+        finally {
+            setPending(false);
+        }
+    };
+    const sendReply = async () => {
+        if (pending || task === undefined || thread === undefined || draft.trim() === '')
+            return;
+        const id = replyRequestId ?? crypto.randomUUID();
+        setReplyRequestId(id);
+        setPending(true);
+        setError(undefined);
+        try {
+            const result = await reply({ requestId: id, workspaceId, taskRef: task.taskRef, body: draft.trim(), baseRevision: thread.revision, recipients: [...recipients].sort(), ...(confirmation === undefined ? {} : { confirmationToken: confirmation }) });
+            if (!result.ok) {
+                setError(result.error.message);
+                return;
+            }
+            if (result.value.kind === 'committed') {
+                const committed = result.value;
+                setCurrentFacts(current => {
+                    const merged = mergeFacts(current, [{ kind: 'message', sequence: committed.message.sequence, message: committed.message, mentions: [...recipients].sort() }]);
+                    currentFactsRef.current = merged;
+                    return merged;
+                });
+                setProjection(current => current === undefined ? current : { ...current, task: committed.task, thread: committed.thread });
+                setDraft('');
+                setRecipients(new Set());
+                setReplyRequestId(undefined);
+                setConfirmation(undefined);
+                setStatusMessage(undefined);
+                await refreshSupplemental();
+            }
+            else if (result.value.kind === 'confirmation_required') {
+                setConfirmation(result.value.confirmationToken);
+                setStatusMessage(t('mentionConfirmation'));
+            }
+            else if (result.value.kind === 'unread_required') {
+                setError(t('unreadRequired', { count: result.value.unreadCount }));
+                setConfirmation(undefined);
+                setStatusMessage(undefined);
+                setReplyRequestId(undefined);
+                await refreshAfterFence();
+            }
+            else if (result.value.kind === 'stale_revision') {
+                setError(t('staleRevision'));
+                setConfirmation(undefined);
+                setStatusMessage(undefined);
+                setReplyRequestId(undefined);
+                await refreshPassiveFacts();
+            }
+            else {
+                setError(t('memberNotFollowing', { ids: result.value.memberIds.map(memberId => `@${members.find(candidate => candidate.member.memberId === memberId)?.member.handle ?? memberId}`).join(', ') }));
+                setConfirmation(undefined);
+                setStatusMessage(undefined);
+                setReplyRequestId(undefined);
+            }
+        }
+        catch (cause) {
+            setError(cause instanceof Error ? cause.message : String(cause));
+        }
+        finally {
+            setPending(false);
+        }
+    };
+    const currentFactsWithAnchor = mergeFacts(activeProjection === undefined ? [] : [messageFact(activeProjection.anchor, activeProjection.anchorMentions)], currentFacts);
+    const unreadBoundary = unreadIndex >= 0 ? unreadIndex : undefined;
+    const risks = taskClaims.filter(claim => claim.state === 'active').flatMap(claim => {
+        const status = members.find(candidate => candidate.member.memberId === claim.owner);
+        return status?.presence === 'error' ? [{ claim, status }] : [];
+    });
+    // Threads are always entered through a Channel page, so a Channel origin
+    // returns to its timeline; a Thread restored without one returns further.
+    const backLabel = channelRef === undefined ? t('backToWorkspace') : t('backToChannel');
+    return _jsxs("main", { className: css.surface, "data-team-thread": threadRef, children: [_jsxs("div", { className: css.surfaceHeader, children: [_jsx("div", { className: css.backRow, children: _jsx(Button, { size: "sm", icon: _jsx(IconChevronLeftOutline14, {}), onClick: backToWorkspace, children: backLabel }) }), _jsxs("header", { className: css.headerRow, children: [_jsxs("div", { className: css.headerCopy, children: [_jsxs("div", { className: threadCss.titleLine, children: [_jsx("h1", { children: task === undefined ? t('taskPending') : t('taskLabel', { number: taskNumber ?? '…' }) }), task !== undefined && _jsx(Pill, { children: formatTaskStatus(task.status, t) })] }), taskTitle !== undefined && taskTitle !== '' && _jsx("p", { className: threadCss.taskTitle, children: taskTitle })] }), task !== undefined && thread !== undefined && task.resolution !== 'closed' && _jsxs("div", { className: css.headerActions, children: [task.status === 'in_review' && task.resolution === 'open' && _jsx(Button, { size: "sm", variant: "primary", disabled: pending, onClick: () => { void mutateTask('accept'); }, children: t('acceptTask') }), task.resolution === 'open'
+                                        ? _jsx(Button, { size: "sm", variant: "outline", disabled: pending, onClick: () => { void mutateTask('close'); }, children: t('closeTask') })
+                                        : _jsx(Button, { size: "sm", variant: "primary", disabled: pending, onClick: () => { void mutateTask('reopen'); }, children: t('reopenTask') })] })] }), risks.length > 0 && _jsxs("section", { className: threadCss.riskSection, "aria-label": t('runtimeRisk'), children: [_jsx("h2", { children: t('runtimeRisk') }), risks.map(({ claim, status }) => _jsxs("p", { className: threadCss.riskRow, children: [_jsx(TeamPresenceDot, { status: status, t: t }), _jsxs("span", { children: [t('runtimeRiskDetail', { member: status.member.handle, diagnostic: status.diagnostic ?? t('statusError') }), " \u00B7 ", claim.direction] })] }, claim.claimRef))] }), task !== undefined && thread !== undefined && _jsx("section", { className: threadCss.workSection, "aria-label": t('claims'), children: _jsx(DisclosureRow, { expandOnRowClick: true, expandable: true, open: claimsOpen, onToggle: () => { setClaimsOpen(current => !current); }, icon: _jsx(IconChecklistOutline14, { size: 14 }), title: `${t('claims')} · ${taskClaims.length}`, children: _jsxs("div", { className: threadCss.claimList, children: [taskClaims.length === 0 && _jsx("p", { className: threadCss.emptyClaims, children: t('noClaims') }), taskClaims.map(claim => {
+                                        const ownerStatus = members.find(status => status.member.memberId === claim.owner);
+                                        return _jsxs("article", { className: threadCss.claimRow, children: [ownerStatus === undefined ? _jsx("span", {}) : _jsx(TeamPresenceDot, { status: ownerStatus, t: t }), _jsx("strong", { className: threadCss.claimOwner, children: memberName(claim.owner) }), _jsx("span", { className: threadCss.claimDirection, children: claim.direction }), _jsx("small", { className: threadCss.claimState, children: formatClaimState(claim.state, t) })] }, claim.claimRef);
+                                    })] }) }) })] }), _jsx("section", { ref: timeline.ref, onScroll: timeline.onScroll, className: css.timeline, "aria-label": t('timelineLabel'), children: _jsxs("div", { className: css.timelineContent, children: [loading && projection === undefined && error === undefined && _jsx("div", { className: css.emptySurface, children: _jsxs("p", { className: css.loadingState, children: [_jsx("span", { className: css.loadingMark, "aria-hidden": "true" }), t('loadingThread')] }) }), projection === undefined && error !== undefined && _jsxs("div", { className: css.errorState, role: "alert", children: [_jsx("span", { children: error }), _jsx(Button, { size: "sm", variant: "outline", onClick: () => { void readCurrent(); }, children: t('retry') })] }), olderFacts.length > 0 && _jsxs("section", { className: threadCss.historySection, "aria-label": t('olderHistory'), children: [_jsx("h2", { children: t('olderHistory') }), renderFactBlocks(olderFacts, undefined)] }), historyHasMore && _jsx("div", { className: css.timelineAction, children: _jsx(Button, { size: "sm", onClick: () => { void loadOlder(); }, children: t('loadOlder') }) }), currentFactsWithAnchor.length > 0 && _jsx("section", { className: threadCss.publicSection, children: renderFactBlocks(currentFactsWithAnchor, unreadBoundary) }), newFactsCount > 0 && _jsxs("div", { className: threadCss.newUpdates, role: "status", children: [_jsx("span", { children: t('readNewUpdates', { count: newFactsCount }) }), _jsx(Button, { size: "sm", variant: "outline", disabled: loading, onClick: () => { timeline.jumpToLatest(); void readCurrent(true); }, children: t('markRead') })] }), remainingUnreadCount > 0 && _jsxs("div", { className: css.timelineAction, role: "status", children: [_jsx("span", { children: t('remainingUnread', { count: remainingUnreadCount }) }), _jsx(Button, { size: "sm", onClick: () => { timeline.jumpToBoundary(); void readCurrent(true); }, disabled: loading, children: t('continueReading') })] })] }) }), projection !== undefined && task !== undefined && thread !== undefined ? (task.resolution === 'closed'
+                ? _jsxs("div", { className: threadCss.closedBar, "data-team-closed": true, children: [error !== undefined && _jsx("p", { className: css.error, role: "alert", children: error }), _jsxs("div", { className: threadCss.closedNotice, children: [_jsx("span", { children: t('taskClosedNotice') }), _jsx(Button, { size: "sm", variant: "outline", disabled: pending, onClick: () => { void mutateTask('reopen'); }, children: t('reopenTask') })] })] })
+                : _jsx(TeamComposer, { members: channelMembers, recipients: recipients, draft: draft, pending: pending, ...(statusMessage === undefined ? {} : { confirmation: statusMessage }), ...(error === undefined ? {} : { error }), onDraftChange: next => { setDraft(next); setConfirmation(undefined); setReplyRequestId(undefined); setStatusMessage(undefined); }, onRecipientsChange: next => { setRecipients(next); setConfirmation(undefined); setReplyRequestId(undefined); setStatusMessage(undefined); }, onSubmit: () => { void sendReply(); }, t: t })) : _jsx("div", {})] });
+}

package/packages/client-agent-team/lib/types/client/TeamWorkspaceBrowser.d.ts

@@ -0,0 +1,3 @@
+import type { TeamSidebarProps } from './slots.ts';
+export declare function TeamWorkspaceBrowser({ wide, expandSidebar, navigation, selectWorkspace, selectChannel, t, useWorkspaces, loadMembers, subscribeChanges, addMember, loadChannels, createChannel, updateChannel, updateMember, joinChannel, removeChannelMember, loadModels, openMemberSession }: TeamSidebarProps): import("react").JSX.Element;
+//# sourceMappingURL=TeamWorkspaceBrowser.d.ts.map

package/packages/client-agent-team/lib/types/client/TeamWorkspaceBrowser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TeamWorkspaceBrowser.d.ts","sourceRoot":"","sources":["../../../src/client/TeamWorkspaceBrowser.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAQlD,wBAAgB,oBAAoB,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,eAAe,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,EAAE,WAAW,EAAE,gBAAgB,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY,EAAE,WAAW,EAAE,mBAAmB,EAAE,UAAU,EAAE,iBAAiB,EAAE,EAAE,gBAAgB,+BA2DhT"}

package/packages/client-agent-team/lib/types/client/TeamWorkspaceBrowser.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState, useSyncExternalStore } from 'react';
+import { IconAgentPresetOutline16, IconListPenOutline16, Tooltip } from '@deepseek-ai/dsh-client-ui-primitives';
+import { TeamWorkspaceRow } from "./TeamWorkspaceRow.js";
+import { TeamAgentsPanel } from "./TeamAgentsPanel.js";
+import { TeamChannelsPanel } from "./TeamChannelsPanel.js";
+import css from './sidebar.module.css';
+export function TeamWorkspaceBrowser({ wide, expandSidebar, navigation, selectWorkspace, selectChannel, t, useWorkspaces, loadMembers, subscribeChanges, addMember, loadChannels, createChannel, updateChannel, updateMember, joinChannel, removeChannelMember, loadModels, openMemberSession }) {
+    const navigationState = useSyncExternalStore(navigation.subscribe, navigation.getSnapshot, navigation.getSnapshot);
+    const workspaces = useWorkspaces(state => state.items);
+    const selected = navigationState.workspaceId;
+    const selectedExists = selected !== undefined && workspaces.some(workspace => workspace.workspaceId === selected);
+    const selectedId = selectedExists ? selected : workspaces[0]?.workspaceId;
+    // Exactly one sidebar row carries aria-current='page': the open Channel while
+    // one is set, otherwise the browsed Workspace's overview. The selected row
+    // keeps its quiet folder tint (data-selected) in both cases.
+    const overviewIsCurrent = navigationState.channelRef === undefined;
+    const [creatingAgents, setCreatingAgents] = useState([]);
+    // Rail icons request expansion and name the section to reveal once wide.
+    const [pendingSection, setPendingSection] = useState();
+    const channelsRef = useRef(null);
+    const agentsRef = useRef(null);
+    useEffect(() => {
+        if (navigationState.mode === 'team' && selectedId !== undefined && selectedId !== selected) {
+            selectWorkspace(selectedId);
+        }
+    }, [navigationState.mode, selected, selectedId, selectWorkspace]);
+    useEffect(() => {
+        if (!wide || pendingSection === undefined)
+            return;
+        const node = pendingSection === 'agents' ? agentsRef.current : channelsRef.current;
+        setPendingSection(undefined);
+        queueMicrotask(() => { node?.querySelector('button')?.focus(); });
+    }, [wide, pendingSection]);
+    if (!wide) {
+        return _jsxs("nav", { className: css.railWorkspace, "aria-label": t('workspaceSections'), children: [_jsx(Tooltip, { label: t('channels'), side: "right", children: _jsx("button", { type: "button", className: css.railButton, "aria-label": t('channels'), onClick: () => { setPendingSection('channels'); expandSidebar(); }, children: _jsx(IconListPenOutline16, { size: 16 }) }) }), _jsx(Tooltip, { label: t('agents'), side: "right", children: _jsx("button", { type: "button", className: css.railButton, "aria-label": t('agents'), onClick: () => { setPendingSection('agents'); expandSidebar(); }, children: _jsx(IconAgentPresetOutline16, { size: 16 }) }) })] });
+    }
+    return _jsxs("section", { className: css.workspaceBrowser, "aria-label": t('workspaces'), children: [_jsx("div", { className: css.workspaceHeader, children: t('workspaces') }), _jsxs("div", { className: css.workspaceList, children: [workspaces.map(workspace => _jsx(TeamWorkspaceRow, { workspaceId: workspace.workspaceId, title: workspace.title, path: workspace.path, selected: workspace.workspaceId === selectedId, current: workspace.workspaceId === selectedId && overviewIsCurrent, onSelect: selectWorkspace }, workspace.workspaceId)), workspaces.length === 0 && _jsx("p", { className: css.emptyState, children: t('empty') })] }), selectedId !== undefined && _jsxs("div", { className: css.workspaceSection, children: [_jsx("div", { ref: channelsRef, children: _jsx(TeamChannelsPanel, { workspaceId: selectedId, loadMembers: loadMembers, loadChannels: loadChannels, subscribeChanges: subscribeChanges, createChannel: createChannel, updateChannel: updateChannel, joinChannel: joinChannel, removeChannelMember: removeChannelMember, creatingAgents: creatingAgents.filter(request => request.workspaceId === selectedId), ...(navigationState.channelRef === undefined ? {} : { selectedChannelRef: navigationState.channelRef }), selectChannel: selectChannel, t: t }, selectedId) }), _jsx("div", { ref: agentsRef, children: _jsx(TeamAgentsPanel, { workspaceId: selectedId, loadMembers: loadMembers, subscribeChanges: subscribeChanges, loadChannels: loadChannels, addMember: addMember, updateMember: updateMember, joinChannel: joinChannel, removeChannelMember: removeChannelMember, loadModels: loadModels, openMemberSession: openMemberSession, onCreatingChange: (request, creating) => { setCreatingAgents(current => creating ? [...current.filter(item => item.requestId !== request.requestId), request] : current.filter(item => item.requestId !== request.requestId)); }, t: t }, selectedId) })] })] });
+}

package/packages/client-agent-team/lib/types/client/TeamWorkspaceRow.d.ts

@@ -0,0 +1,11 @@
+import type { WorkspaceId } from '@deepseek-ai/dsh-client-runtime/client';
+export declare function TeamWorkspaceRow({ workspaceId, title, path, selected, current, onSelect }: {
+    workspaceId: WorkspaceId;
+    title: string;
+    path: string;
+    selected: boolean;
+    /** The Team center shows this Workspace's overview (no Channel is open). */
+    current: boolean;
+    onSelect: (workspaceId: WorkspaceId) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=TeamWorkspaceRow.d.ts.map

package/packages/client-agent-team/lib/types/client/TeamWorkspaceRow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TeamWorkspaceRow.d.ts","sourceRoot":"","sources":["../../../src/client/TeamWorkspaceRow.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAA;AAGzE,wBAAgB,gBAAgB,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE;IAC1F,WAAW,EAAE,WAAW,CAAA;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;IACjB,4EAA4E;IAC5E,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,IAAI,CAAA;CAC7C,+BAgBA"}

package/packages/client-agent-team/lib/types/client/TeamWorkspaceRow.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { IconFolderClose16, IconFolderOpen16 } from '@deepseek-ai/dsh-client-ui-primitives';
+import css from './sidebar.module.css';
+export function TeamWorkspaceRow({ workspaceId, title, path, selected, current, onSelect }) {
+    return (_jsxs("button", { type: "button", className: css.workspaceRow, "data-selected": selected || undefined, "aria-current": current ? 'page' : undefined, onClick: () => { onSelect(workspaceId); }, title: `${title} · ${path}`, children: [_jsx("span", { className: css.workspaceIcon, "aria-hidden": "true", children: selected ? _jsx(IconFolderOpen16, { size: 16 }) : _jsx(IconFolderClose16, { size: 16 }) }), _jsx("span", { className: css.workspaceCopy, children: _jsx("strong", { children: title }) })] }));
+}

package/packages/client-agent-team/lib/types/client/index.d.ts

@@ -0,0 +1,19 @@
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+import { TeamNavigation } from './navigation.ts';
+import { type TeamKey } from './locales.ts';
+export type { TeamMode, TeamNavigationActions, TeamNavigationSnapshot } from './navigation.ts';
+export type { TeamKey } from './locales.ts';
+export { TeamNavigation } from './navigation.ts';
+export declare const inject: string[];
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        team: TeamKey;
+    }
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        teamNavigation: TeamNavigation;
+    }
+}
+export declare function apply(ctx: ClientContext): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/packages/client-agent-team/lib/types/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAa,MAAM,wCAAwC,CAAA;AA0BtF,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAMhD,OAAO,EAAU,KAAK,OAAO,EAAE,MAAM,cAAc,CAAA;AAEnD,YAAY,EAAE,QAAQ,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAA;AAC9F,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAIhD,eAAO,MAAM,MAAM,UAElB,CAAA;AAED,OAAO,QAAQ,kCAAkC,CAAC;IAChD,UAAU,kBAAkB;QAC1B,IAAI,EAAE,OAAO,CAAA;KACd;CACF;AAED,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,OAAO;QACf,cAAc,EAAE,cAAc,CAAA;KAC/B;CACF;AA+GD,wBAAsB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAI7D"}