@wowyuarm/dsh-agent-team 0.1.2 → 0.1.4

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

@@ -6,9 +6,10 @@ import { TeamPresenceDot } from "./TeamPresenceDot.js";
 import { TeamMessage } from "./TeamMessage.js";
 import { TeamRunDivider } from "./TeamRunDivider.js";
 import { formatActivity, formatClaimState, formatTaskStatus, formatTaskTitle, mentionNamesOf } from "./team-formatters.js";
+import { mintRequestId } from "./requests.js";
 import { daySeparatorLabel, isRunGap, timelineDayKey } from "./team-separators.js";
 import { useTimelineScroll } from "./timeline-scroll.js";
-import { rememberResolvedTaskRef } from "./task-refs.js";
+import { hostTaskRefLookup, jumpToTaskThread } from "./task-refs.js";
 import { bytesToBase64 } from "./attachment-preview.js";
 import css from './conversation.module.css';
 import threadCss from './thread.module.css';
@@ -32,7 +33,8 @@ function readMeta(facts) {
     return new Map(facts.map(fact => [factKey(fact.fact), fact]));
 }
 export function TeamThreadPage(props) {
-    const { workspaceId, channelRef, taskRef, threadRef, taskNumber, backToWorkspace, selectChannel, selectThread, resolveTaskRefs, putAttachment, loadChannels, readThread, loadThreadHistory, subscribeChanges, loadMembers, drafts, getAttachment, reply, changeTask, t, } = props;
+    const { workspaceId, channelRef, taskRef, threadRef, taskNumber, backToWorkspace, selectChannel, selectThread, resolveTaskRefs, putAttachment, loadChannels, readThread, loadThreadHistory, subscribeChanges, loadMembers, drafts, getAttachment, reply, changeTask, promoteThread, t, } = props;
+    const threadRequest = { threadRef, ...(taskRef === undefined ? {} : { taskRef }) };
     const [projection, setProjection] = useState();
     const [channelView, setChannelView] = useState();
     const [members, setMembers] = useState([]);
@@ -52,19 +54,22 @@ export function TeamThreadPage(props) {
     // confirm dialog lists exactly what will be completed with the Task.
     const [confirmingAccept, setConfirmingAccept] = useState(false);
     useEffect(() => {
-        if (confirmingAccept && projection?.task.resolution === 'accepted')
+        if (confirmingAccept && projection?.task?.resolution === 'accepted')
             setConfirmingAccept(false);
-    }, [confirmingAccept, projection?.task.resolution]);
+    }, [confirmingAccept, projection?.task?.resolution]);
     const [replyRequestId, setReplyRequestId] = useState();
     const [confirmation, setConfirmation] = useState();
     const [statusMessage, setStatusMessage] = useState();
     const [pending, setPending] = useState(false);
+    // Label source for the promote/accept buttons only: a reply send also raises
+    // the shared `pending` gate, and must not retitle those buttons.
+    const [mutating, setMutating] = useState();
     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 readRequestIdRef = useRef(mintRequestId());
     const mutationRequests = useRef(new Map());
     const threadLastFact = currentFacts[currentFacts.length - 1];
     const timeline = useTimelineScroll(`${currentFacts.length}:${olderFacts.length}:${threadLastFact === undefined ? '' : factKey(threadLastFact)}`);
@@ -85,12 +90,12 @@ export function TeamThreadPage(props) {
         if (!mountedRef.current)
             return false;
         if (newRequest)
-            readRequestIdRef.current = crypto.randomUUID();
+            readRequestIdRef.current = mintRequestId();
         const sequence = sequenceRef.current + 1;
         sequenceRef.current = sequence;
         setLoading(true);
         try {
-            const result = await readThread({ requestId: readRequestIdRef.current, workspaceId, taskRef });
+            const result = await readThread({ requestId: readRequestIdRef.current, workspaceId, ...threadRequest });
             if (!mountedRef.current || sequence !== sequenceRef.current)
                 return false;
             if (!result.ok) {
@@ -134,7 +139,7 @@ export function TeamThreadPage(props) {
     };
     const refreshPassiveFacts = async () => {
         try {
-            const result = await loadThreadHistory({ workspaceId, taskRef, limit: 100 });
+            const result = await loadThreadHistory({ workspaceId, ...threadRequest, limit: 100 });
             if (!mountedRef.current || !result.ok)
                 return;
             const incoming = result.value.facts;
@@ -152,7 +157,7 @@ export function TeamThreadPage(props) {
                 currentFactsRef.current = merged;
                 return merged;
             });
-            setProjection(current => current === undefined ? current : { ...current, task: result.value.task, thread: result.value.thread, claims: result.value.claims });
+            setProjection(current => current === undefined ? current : { ...current, ...(result.value.task === undefined ? {} : { 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
@@ -199,8 +204,8 @@ export function TeamThreadPage(props) {
             // 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),
+                readThread({ requestId: readRequestIdRef.current, workspaceId, ...threadRequest }),
+                loadThreadHistory({ workspaceId, ...threadRequest, limit: 20 }).catch(() => undefined),
             ]);
             if (!mountedRef.current || sequence !== sequenceRef.current)
                 return;
@@ -261,7 +266,7 @@ export function TeamThreadPage(props) {
             return;
         setLoading(true);
         try {
-            const result = await loadThreadHistory({ workspaceId, taskRef, beforeSequence, limit: 20 });
+            const result = await loadThreadHistory({ workspaceId, ...threadRequest, beforeSequence, limit: 20 });
             if (!mountedRef.current)
                 return;
             if (!result.ok) {
@@ -285,6 +290,7 @@ export function TeamThreadPage(props) {
     const activeProjection = projection;
     const task = activeProjection?.task;
     const thread = activeProjection?.thread;
+    const resolvedTaskNumber = taskNumber ?? channelView?.taskNumbers.find(entry => entry.taskRef === task?.taskRef)?.taskNumber;
     const taskTitle = activeProjection === undefined ? undefined : formatTaskTitle(activeProjection.anchor.body);
     const taskClaims = activeProjection?.claims ?? [];
     const effectiveChannelRef = task?.channelRef ?? channelRef;
@@ -293,7 +299,7 @@ export function TeamThreadPage(props) {
     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]);
+        const all = mergeFacts(...(activeProjection === undefined ? [] : [[messageFact(activeProjection.anchor, 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) => {
@@ -312,24 +318,10 @@ export function TeamThreadPage(props) {
             selectChannel(ref);
         if (ref.startsWith('task:') && ref !== taskRef) {
             // Another Task cited here: resolve its home Channel and jump.
-            void resolveTaskRefs({ workspaceId, taskRefs: [ref] })
-                .then(result => {
-                if (!result.ok)
-                    return;
-                const hit = result.value.resolved[0];
-                if (hit !== undefined)
-                    selectThread(hit.taskRef, hit.threadRef, hit.channelRef, hit.taskNumber);
-            });
+            jumpToTaskThread(resolveTaskRefs, workspaceId, ref, selectThread);
         }
     };
-    const lookupTaskRefs = (refs) => resolveTaskRefs({ workspaceId, taskRefs: refs })
-        .then(result => {
-        if (!result.ok)
-            return [];
-        for (const entry of result.value.resolved)
-            rememberResolvedTaskRef(entry);
-        return result.value.resolved;
-    });
+    const lookupTaskRefs = hostTaskRefLookup(resolveTaskRefs, workspaceId);
     const renderFact = (fact, grouped = false) => {
         if (fact.kind === 'message') {
             const sender = memberName(fact.message.sender);
@@ -384,13 +376,62 @@ export function TeamThreadPage(props) {
         await readCurrent(true);
         await refreshSupplemental();
     };
+    const convertToTask = async () => {
+        if (pending || thread === undefined || task !== undefined)
+            return;
+        setPending(true);
+        setMutating('promote');
+        setError(undefined);
+        const key = 'promote';
+        const requestId = mutationRequests.current.get(key) ?? mintRequestId();
+        mutationRequests.current.set(key, requestId);
+        try {
+            const result = await promoteThread({ requestId, workspaceId, threadRef, 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 });
+                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);
+            setMutating(undefined);
+        }
+    };
     const mutateTask = async (action) => {
         if (pending || task === undefined || thread === undefined)
             return;
         setPending(true);
+        if (action === 'accept')
+            setMutating('accept');
         setError(undefined);
         const key = `task:${action}`;
-        const requestId = mutationRequests.current.get(key) ?? crypto.randomUUID();
+        const requestId = mutationRequests.current.get(key) ?? mintRequestId();
         mutationRequests.current.set(key, requestId);
         try {
             const result = await changeTask({ requestId, workspaceId, taskRef: task.taskRef, action, baseRevision: thread.revision });
@@ -426,12 +467,13 @@ export function TeamThreadPage(props) {
         }
         finally {
             setPending(false);
+            setMutating(undefined);
         }
     };
     const sendReply = async () => {
-        if (pending || task === undefined || thread === undefined || draft.trim() === '')
+        if (pending || thread === undefined || draft.trim() === '')
             return;
-        const id = replyRequestId ?? crypto.randomUUID();
+        const id = replyRequestId ?? mintRequestId();
         setReplyRequestId(id);
         setPending(true);
         setError(undefined);
@@ -441,7 +483,7 @@ export function TeamThreadPage(props) {
             const attachmentIds = [];
             for (const file of pendingFiles) {
                 const uploaded = await putAttachment({
-                    requestId: crypto.randomUUID(),
+                    requestId: mintRequestId(),
                     workspaceId,
                     name: file.name,
                     mediaType: file.type === '' ? undefined : file.type,
@@ -453,7 +495,7 @@ export function TeamThreadPage(props) {
                 }
                 attachmentIds.push(uploaded.value.attachmentId);
             }
-            const result = await reply({ requestId: id, workspaceId, taskRef: task.taskRef, body: draft.trim(), baseRevision: thread.revision, recipients: [...recipients].sort(), ...(attachmentIds.length === 0 ? {} : { attachments: attachmentIds }), ...(confirmation === undefined ? {} : { confirmationToken: confirmation }) });
+            const result = await reply({ requestId: id, workspaceId, threadRef, ...(task === undefined ? {} : { taskRef: task.taskRef }), body: draft.trim(), baseRevision: thread.revision, recipients: [...recipients].sort(), ...(attachmentIds.length === 0 ? {} : { attachments: attachmentIds }), ...(confirmation === undefined ? {} : { confirmationToken: confirmation }) });
             if (!result.ok) {
                 setError(result.error.message);
                 return;
@@ -465,7 +507,7 @@ export function TeamThreadPage(props) {
                     currentFactsRef.current = merged;
                     return merged;
                 });
-                setProjection(current => current === undefined ? current : { ...current, task: committed.task, thread: committed.thread });
+                setProjection(current => current === undefined ? current : { ...current, ...(committed.task === undefined ? {} : { task: committed.task }), thread: committed.thread });
                 drafts.clear(draftKey);
                 setPendingFiles([]);
                 setReplyRequestId(undefined);
@@ -514,7 +556,7 @@ export function TeamThreadPage(props) {
     // 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: [(() => {
+    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('threadLabel') : t('taskLabel', { number: resolvedTaskNumber ?? '…' }) }), task !== undefined && _jsx(Pill, { children: formatTaskStatus(task.status, t) })] }), taskTitle !== undefined && taskTitle !== '' && _jsx("p", { className: threadCss.taskTitle, title: taskTitle, children: taskTitle })] }), task === undefined && thread !== undefined && _jsx("div", { className: css.headerActions, children: _jsx(Button, { size: "sm", variant: "primary", disabled: pending, onClick: () => { void convertToTask(); }, children: mutating === 'promote' ? t('promotingTask') : t('promoteToTask') }) }), task !== undefined && thread !== undefined && task.resolution !== 'closed' && _jsxs("div", { className: css.headerActions, children: [(() => {
                                         const activeClaims = projection?.claims.filter(claim => claim.taskRef === task.taskRef && claim.state === 'active') ?? [];
                                         const earlyAccept = task.resolution === 'open' && task.status === 'in_progress' && activeClaims.length > 0;
                                         if (!(task.status === 'in_review' || earlyAccept) || task.resolution !== 'open')
@@ -531,11 +573,11 @@ export function TeamThreadPage(props) {
                         // Recomputed here so the confirm list never shows stale rows.
                         const activeClaims = projection?.claims.filter(claim => claim.taskRef === task.taskRef && claim.state === 'active') ?? [];
                         return _jsxs(Modal, { open: confirmingAccept, onClose: () => { if (!pending)
-                                setConfirmingAccept(false); }, title: t('acceptEarlyTitle'), closeLabel: t('cancel'), footer: _jsxs(_Fragment, { children: [_jsx(Button, { variant: "outline", disabled: pending, onClick: () => { setConfirmingAccept(false); }, children: t('cancel') }), _jsx(Button, { variant: "primary", disabled: pending, onClick: () => { void mutateTask('accept'); }, children: pending ? t('acceptingTask') : t('acceptTask') })] }), children: [_jsx("p", { className: css.confirmBody, children: t('acceptEarlyBody', { count: activeClaims.length }) }), _jsx("ul", { className: css.confirmList, children: activeClaims.map(claim => (_jsxs("li", { children: [memberName(claim.owner), " \u00B7 ", claim.direction] }, claim.claimRef))) })] });
+                                setConfirmingAccept(false); }, title: t('acceptEarlyTitle'), closeLabel: t('cancel'), footer: _jsxs(_Fragment, { children: [_jsx(Button, { variant: "outline", disabled: pending, onClick: () => { setConfirmingAccept(false); }, children: t('cancel') }), _jsx(Button, { variant: "primary", disabled: pending, onClick: () => { void mutateTask('accept'); }, children: mutating === 'accept' ? t('acceptingTask') : t('acceptTask') })] }), children: [_jsx("p", { className: css.confirmBody, children: t('acceptEarlyBody', { count: activeClaims.length }) }), _jsx("ul", { className: css.confirmList, children: activeClaims.map(claim => (_jsxs("li", { children: [memberName(claim.owner), " \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'
+                                    })] }) }) })] }), _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 && 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 => { drafts.writeDraft(draftKey, next); setConfirmation(undefined); setReplyRequestId(undefined); setStatusMessage(undefined); }, onRecipientsChange: next => { drafts.writeRecipients(draftKey, next); setConfirmation(undefined); setReplyRequestId(undefined); setStatusMessage(undefined); }, onSubmit: () => { void sendReply(); }, pendingFiles: pendingFiles, onFilesChange: setPendingFiles, t: t }, draftKey)) : _jsx("div", {})] });
+                : _jsx(TeamComposer, { members: channelMembers, recipients: recipients, draft: draft, pending: pending, ...(statusMessage === undefined ? {} : { confirmation: statusMessage }), ...(error === undefined ? {} : { error }), onDraftChange: next => { drafts.writeDraft(draftKey, next); setConfirmation(undefined); setReplyRequestId(undefined); setStatusMessage(undefined); }, onRecipientsChange: next => { drafts.writeRecipients(draftKey, next); setConfirmation(undefined); setReplyRequestId(undefined); setStatusMessage(undefined); }, onSubmit: () => { void sendReply(); }, placeholder: t('replyPlaceholder'), pendingFiles: pendingFiles, onFilesChange: setPendingFiles, t: t }, draftKey)) : _jsx("div", {})] });
 }

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

@@ -1 +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,aAAa,EAAE,WAAW,EAAE,mBAAmB,EAAE,UAAU,EAAE,iBAAiB,EAAE,EAAE,gBAAgB,+BA4D/T"}
+{"version":3,"file":"TeamWorkspaceBrowser.d.ts","sourceRoot":"","sources":["../../../src/client/TeamWorkspaceBrowser.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AASlD,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,aAAa,EAAE,WAAW,EAAE,mBAAmB,EAAE,UAAU,EAAE,iBAAiB,EAAE,EAAE,gBAAgB,+BA6D/T"}

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

@@ -2,6 +2,7 @@ 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 { TeamSidebarSection } from "./TeamSidebarSection.js";
 import { TeamAgentsPanel } from "./TeamAgentsPanel.js";
 import { TeamChannelsPanel } from "./TeamChannelsPanel.js";
 import css from './sidebar.module.css';
@@ -36,5 +37,5 @@ export function TeamWorkspaceBrowser({ wide, expandSidebar, navigation, selectWo
     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.memberSessionId !== undefined || 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, recoverMember: recoverMember, joinChannel: joinChannel, removeChannelMember: removeChannelMember, loadModels: loadModels, ...(navigationState.memberSessionId === undefined ? {} : { memberSessionId: navigationState.memberSessionId }), 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) })] })] });
+    return _jsxs("section", { className: css.workspaceBrowser, "aria-label": t('workspaces'), children: [_jsx(TeamSidebarSection, { title: t('workspaces'), children: _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.memberSessionId !== undefined || 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, recoverMember: recoverMember, joinChannel: joinChannel, removeChannelMember: removeChannelMember, loadModels: loadModels, ...(navigationState.memberSessionId === undefined ? {} : { memberSessionId: navigationState.memberSessionId }), 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/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAa,MAAM,wCAAwC,CAAA;AA8BtF,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAK5C,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;QAC9B,UAAU,EAAE,cAAc,CAAA;KAC3B;CACF;AAoJD,wBAAsB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAI7D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAa,MAAM,wCAAwC,CAAA;AAgCtF,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAO5C,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;QAC9B,UAAU,EAAE,cAAc,CAAA;KAC3B;CACF;AAwND,wBAAsB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAI7D"}

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

@@ -6,11 +6,13 @@ import { TeamFooterAction } from "./TeamFooterAction.js";
 import { TeamSettings } from "./TeamSettings.js";
 import { TeamConversation } from "./TeamConversation.js";
 import { TeamWorkspaceBrowser } from "./TeamWorkspaceBrowser.js";
+import { TeamMemberSessionComposer } from "./TeamMemberSessionComposer.js";
+import { admitTeamCompact, createTeamMemberSessionSources } from "./member-session-input.js";
 import { en, zh } from "./locales.js";
 export { TeamNavigation } from "./navigation.js";
 const NS = 'team';
 export const inject = [
-    'slots', 'workspaces', 'locale', 'remote', 'sessions', 'connection',
+    'slots', 'workspaces', 'locale', 'remote', 'sessions', 'connection', 'conversation', 'inputTriggers',
 ];
 function registerModeShadow(ctx, navigation, changes, drafts, name, component, extraInject) {
     // Remote bindings shared by every Team slot; surface-specific entries extend it below.
@@ -70,6 +72,7 @@ function registerModeShadow(ctx, navigation, changes, drafts, name, component, e
                             getAttachment: (request) => ctx.remote.agentTeam.getAttachment(request),
                             reply: (request) => ctx.remote.agentTeam.reply(request),
                             changeTask: (request) => ctx.remote.agentTeam.changeTask(request),
+                            promoteThread: (request) => ctx.remote.agentTeam.promoteThread(request),
                             resolveTaskRefs: (request) => ctx.remote.agentTeam.resolveTaskRefs(request),
                         } : {}),
                         ...(name === 'sidebar.workspaces' ? {
@@ -93,6 +96,49 @@ function registerModeShadow(ctx, navigation, changes, drafts, name, component, e
         };
     });
 }
+function registerMemberSessionComposer(ctx, navigation) {
+    ctx.slots.inject('conversation.composer.bar', () => {
+        let dispose;
+        let registeredSessionId;
+        const reconcile = () => {
+            const memberSessionId = navigation.getSnapshot().memberSessionId;
+            const active = navigation.getSnapshot().mode === 'team' && memberSessionId !== undefined;
+            if (dispose !== undefined && (!active || registeredSessionId !== memberSessionId)) {
+                dispose();
+                dispose = undefined;
+                registeredSessionId = undefined;
+            }
+            if (active && dispose === undefined) {
+                registeredSessionId = memberSessionId;
+                dispose = ctx.slots.register({
+                    name: 'conversation.composer.bar',
+                    priority: -100,
+                    // The registration may remain live during a session transition, but
+                    // it elects only when the shell's current Session is the embedded
+                    // Member. This avoids taking an ordinary Session if selection races.
+                    select: () => ctx.sessions.list.getSnapshot().current === memberSessionId ? {} : null,
+                    inject: (sessionId) => {
+                        const actx = ctx.sessions.scope(sessionId);
+                        if (actx === undefined)
+                            throw new Error(`agent-team: Member session ${String(sessionId)} has no client scope`);
+                        const sessions = ctx.sessions;
+                        return {
+                            controller: ctx.get('inputTriggers').sessionOf(actx),
+                            stop: () => { void sessions.sessionOf(actx)?.cancel(); },
+                            submitInput: (mode) => ctx.conversation.input.for(actx).submit(mode),
+                        };
+                    },
+                }, TeamMemberSessionComposer);
+            }
+        };
+        const offNavigation = navigation.subscribe(reconcile);
+        reconcile();
+        return () => {
+            offNavigation();
+            dispose?.();
+        };
+    });
+}
 function applyUi(ctx) {
     ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'agent-team: dictionaries');
     const navigation = new TeamNavigation();
@@ -106,6 +152,30 @@ function applyUi(ctx) {
         void disposeDrafts();
     }, 'agent-team: navigation service');
     const changes = new TeamChangeStream((request, signal) => ctx.remote.agentTeam.changes(request, signal));
+    const triggerSources = createTeamMemberSessionSources({
+        isEmbeddedMemberSession: sessionId => {
+            const snapshot = navigation.getSnapshot();
+            return snapshot.mode === 'team' && snapshot.memberSessionId === sessionId && snapshot.workspaceId !== undefined;
+        },
+        members: async () => {
+            const workspaceId = navigation.getSnapshot().workspaceId;
+            if (workspaceId === undefined)
+                return [];
+            const result = await ctx.remote.agentTeam.members({ workspaceId });
+            return result.ok ? result.value : [];
+        },
+        executeCompact: async (sessionId) => {
+            const actx = ctx.sessions.scope(sessionId);
+            const session = actx === undefined ? undefined : ctx.sessions.sessionOf(actx);
+            return session === undefined ? { kind: 'error', text: 'current Member Session is unavailable' } : admitTeamCompact(session);
+        },
+    });
+    const inputTriggers = ctx.get('inputTriggers');
+    ctx.effect(() => {
+        const disposers = triggerSources.map(source => inputTriggers.registerSource(source));
+        return () => { for (const dispose of disposers)
+            dispose(); };
+    }, 'agent-team: Member session trigger sources');
     const loadMemberGroups = async () => {
         const workspaces = ctx.workspaces.list.getSnapshot().items;
         const groups = await Promise.all(workspaces.map(async (workspace) => {
@@ -144,6 +214,7 @@ function applyUi(ctx) {
     }, TeamFooterAction));
     registerModeShadow(ctx, navigation, changes, drafts, 'sidebar.workspaces', TeamWorkspaceBrowser);
     registerModeShadow(ctx, navigation, changes, drafts, 'conversation', TeamConversation);
+    registerMemberSessionComposer(ctx, navigation);
     registerModeShadow(ctx, navigation, changes, drafts, 'sidebar.settings', TeamSettings, () => ({ loadMemberGroups }));
 }
 export async function apply(ctx) {

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

@@ -37,6 +37,9 @@ export declare const zh: {
     readonly editChannel: "编辑频道";
     readonly editAgent: "编辑 Agent";
     readonly resumeAgent: "恢复";
+    readonly restartAgent: "重启";
+    readonly restartStillUnavailable: "重启已执行，成员仍不可用：{diagnostic}";
+    readonly restartFailed: "重启执行失败：{message}";
     readonly optionalSuffix: "（可选）";
     readonly agentDescriptionPlaceholder: "留空则暂无描述";
     readonly channelsPickerEmpty: "选择初始频道";
@@ -49,6 +52,8 @@ export declare const zh: {
     readonly removeFile: "移除 {name}";
     readonly attachmentExpired: "文件已过期清理";
     readonly viewImage: "查看大图 {name}";
+    readonly expandMessage: "展开全文";
+    readonly collapseMessage: "收起";
     readonly actionsChannel: "{name} 的操作";
     readonly actionsAgent: "{name} 的操作";
     readonly editSave: "保存";
@@ -81,10 +86,16 @@ export declare const zh: {
     readonly taskLabel: "Task #{number}";
     readonly taskPending: "Task …";
     readonly openTask: "打开 Task #{number}";
+    readonly openThread: "打开讨论";
+    readonly threadLabel: "讨论";
+    readonly asTask: "作为任务";
+    readonly promoteToTask: "转为 Task";
+    readonly promotingTask: "正在转为 Task…";
     readonly mentionSuggestions: "提及成员建议";
     readonly messageDraft: "消息内容";
     readonly composerNotify: "将通知：{ids}";
     readonly messagePlaceholder: "写一条消息…";
+    readonly replyPlaceholder: "回复此 Thread…";
     readonly sendMessage: "发送";
     readonly sendingMessage: "发送中…";
     readonly loadOlder: "加载更早消息";
@@ -115,6 +126,7 @@ export declare const zh: {
     readonly activityClaimsReleased: "{actor} 因成员权限变化释放了 {count} 个 Claim";
     readonly activityAccepted: "{actor} 验收了此 Task";
     readonly activityAcceptedWithClaims: "{actor} 验收了此 Task，并一并完成了 {count} 个未完成 Claim";
+    readonly activityPromoted: "{actor} 为此讨论创建了 Task";
     readonly acceptEarlyTitle: "提前验收任务";
     readonly acceptEarlyBody: "将验收本 Task，并把以下 {count} 个未完成的 Claim 一并标记为完成：";
     readonly acceptingTask: "验收中…";
@@ -165,6 +177,9 @@ export declare const en: {
     readonly editChannel: "Edit Channel";
     readonly editAgent: "Edit Agent";
     readonly resumeAgent: "Resume";
+    readonly restartAgent: "Restart";
+    readonly restartStillUnavailable: "Restart ran, but the Member is still unavailable: {diagnostic}";
+    readonly restartFailed: "Restart failed: {message}";
     readonly optionalSuffix: " (optional)";
     readonly agentDescriptionPlaceholder: "Leave empty if not needed";
     readonly channelsPickerEmpty: "Choose initial channels";
@@ -177,6 +192,8 @@ export declare const en: {
     readonly removeFile: "Remove {name}";
     readonly attachmentExpired: "File expired and cleaned up";
     readonly viewImage: "View image {name}";
+    readonly expandMessage: "Show more";
+    readonly collapseMessage: "Show less";
     readonly actionsChannel: "{name} actions";
     readonly actionsAgent: "{name} actions";
     readonly editSave: "Save";
@@ -209,10 +226,16 @@ export declare const en: {
     readonly taskLabel: "Task #{number}";
     readonly taskPending: "Task …";
     readonly openTask: "Open Task #{number}";
+    readonly openThread: "Open thread";
+    readonly threadLabel: "Thread";
+    readonly asTask: "As task";
+    readonly promoteToTask: "Convert to Task";
+    readonly promotingTask: "Converting to Task…";
     readonly mentionSuggestions: "Mention suggestions";
     readonly messageDraft: "Message";
     readonly composerNotify: "Will notify: {ids}";
     readonly messagePlaceholder: "Write a message…";
+    readonly replyPlaceholder: "Reply on this Thread…";
     readonly sendMessage: "Send";
     readonly sendingMessage: "Sending…";
     readonly loadOlder: "Load older messages";
@@ -243,6 +266,7 @@ export declare const en: {
     readonly activityClaimsReleased: "{actor} released {count} Claim(s) after a membership change";
     readonly activityAccepted: "{actor} accepted this Task";
     readonly activityAcceptedWithClaims: "{actor} accepted this Task and completed {count} unfinished Claims with it";
+    readonly activityPromoted: "{actor} created a Task for this Thread";
     readonly acceptEarlyTitle: "Accept Task early";
     readonly acceptEarlyBody: "This accepts the Task and marks the following {count} unfinished Claims as done:";
     readonly acceptingTask: "Accepting…";

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

@@ -1 +1 @@
-{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../../src/client/locales.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+HL,CAAA;AAEV,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+HL,CAAA;AAEV,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,EAAE,CAAA"}
+{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../../src/client/locales.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2IL,CAAA;AAEV,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2IL,CAAA;AAEV,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,EAAE,CAAA"}

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

@@ -37,6 +37,9 @@ export const zh = {
     editChannel: '编辑频道',
     editAgent: '编辑 Agent',
     resumeAgent: '恢复',
+    restartAgent: '重启',
+    restartStillUnavailable: '重启已执行，成员仍不可用：{diagnostic}',
+    restartFailed: '重启执行失败：{message}',
     optionalSuffix: '（可选）',
     agentDescriptionPlaceholder: '留空则暂无描述',
     channelsPickerEmpty: '选择初始频道',
@@ -49,6 +52,8 @@ export const zh = {
     removeFile: '移除 {name}',
     attachmentExpired: '文件已过期清理',
     viewImage: '查看大图 {name}',
+    expandMessage: '展开全文',
+    collapseMessage: '收起',
     actionsChannel: '{name} 的操作',
     actionsAgent: '{name} 的操作',
     editSave: '保存',
@@ -81,10 +86,16 @@ export const zh = {
     taskLabel: 'Task #{number}',
     taskPending: 'Task …',
     openTask: '打开 Task #{number}',
+    openThread: '打开讨论',
+    threadLabel: '讨论',
+    asTask: '作为任务',
+    promoteToTask: '转为 Task',
+    promotingTask: '正在转为 Task…',
     mentionSuggestions: '提及成员建议',
     messageDraft: '消息内容',
     composerNotify: '将通知：{ids}',
     messagePlaceholder: '写一条消息…',
+    replyPlaceholder: '回复此 Thread…',
     sendMessage: '发送',
     sendingMessage: '发送中…',
     loadOlder: '加载更早消息',
@@ -115,6 +126,7 @@ export const zh = {
     activityClaimsReleased: '{actor} 因成员权限变化释放了 {count} 个 Claim',
     activityAccepted: '{actor} 验收了此 Task',
     activityAcceptedWithClaims: '{actor} 验收了此 Task，并一并完成了 {count} 个未完成 Claim',
+    activityPromoted: '{actor} 为此讨论创建了 Task',
     acceptEarlyTitle: '提前验收任务',
     acceptEarlyBody: '将验收本 Task，并把以下 {count} 个未完成的 Claim 一并标记为完成：',
     acceptingTask: '验收中…',
@@ -165,6 +177,9 @@ export const en = {
     editChannel: 'Edit Channel',
     editAgent: 'Edit Agent',
     resumeAgent: 'Resume',
+    restartAgent: 'Restart',
+    restartStillUnavailable: 'Restart ran, but the Member is still unavailable: {diagnostic}',
+    restartFailed: 'Restart failed: {message}',
     optionalSuffix: ' (optional)',
     agentDescriptionPlaceholder: 'Leave empty if not needed',
     channelsPickerEmpty: 'Choose initial channels',
@@ -177,6 +192,8 @@ export const en = {
     removeFile: 'Remove {name}',
     attachmentExpired: 'File expired and cleaned up',
     viewImage: 'View image {name}',
+    expandMessage: 'Show more',
+    collapseMessage: 'Show less',
     actionsChannel: '{name} actions',
     actionsAgent: '{name} actions',
     editSave: 'Save',
@@ -209,10 +226,16 @@ export const en = {
     taskLabel: 'Task #{number}',
     taskPending: 'Task …',
     openTask: 'Open Task #{number}',
+    openThread: 'Open thread',
+    threadLabel: 'Thread',
+    asTask: 'As task',
+    promoteToTask: 'Convert to Task',
+    promotingTask: 'Converting to Task…',
     mentionSuggestions: 'Mention suggestions',
     messageDraft: 'Message',
     composerNotify: 'Will notify: {ids}',
     messagePlaceholder: 'Write a message…',
+    replyPlaceholder: 'Reply on this Thread…',
     sendMessage: 'Send',
     sendingMessage: 'Sending…',
     loadOlder: 'Load older messages',
@@ -243,6 +266,7 @@ export const en = {
     activityClaimsReleased: '{actor} released {count} Claim(s) after a membership change',
     activityAccepted: '{actor} accepted this Task',
     activityAcceptedWithClaims: '{actor} accepted this Task and completed {count} unfinished Claims with it',
+    activityPromoted: '{actor} created a Task for this Thread',
     acceptEarlyTitle: 'Accept Task early',
     acceptEarlyBody: 'This accepts the Task and marks the following {count} unfinished Claims as done:',
     acceptingTask: 'Accepting…',