@wowyuarm/dsh-agent-team 0.1.1 → 0.1.3

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

@@ -1,13 +1,16 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Fragment, useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
-import { Button, DisclosureRow, IconChevronLeftOutline14, IconChecklistOutline14, Pill } from '@deepseek-ai/dsh-client-ui-primitives';
+import { Button, DisclosureRow, IconChevronLeftOutline14, IconChecklistOutline14, Modal, Pill } from '@deepseek-ai/dsh-client-ui-primitives';
 import { TeamComposer } from "./TeamComposer.js";
 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 { hostTaskRefLookup, jumpToTaskThread } from "./task-refs.js";
+import { bytesToBase64 } from "./attachment-preview.js";
 import css from './conversation.module.css';
 import threadCss from './thread.module.css';
 function factKey(fact) {
@@ -30,7 +33,7 @@ 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, 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, t, } = props;
     const [projection, setProjection] = useState();
     const [channelView, setChannelView] = useState();
     const [members, setMembers] = useState([]);
@@ -46,6 +49,13 @@ export function TeamThreadPage(props) {
     const draftKey = `thread:${threadRef}`;
     const { draft, recipients } = useSyncExternalStore(drafts.subscribe, () => drafts.getSnapshot(draftKey));
     const [claimsOpen, setClaimsOpen] = useState(false);
+    // Early acceptance: the Human may accept while Claims are still open; the
+    // confirm dialog lists exactly what will be completed with the Task.
+    const [confirmingAccept, setConfirmingAccept] = useState(false);
+    useEffect(() => {
+        if (confirmingAccept && projection?.task.resolution === 'accepted')
+            setConfirmingAccept(false);
+    }, [confirmingAccept, projection?.task.resolution]);
     const [replyRequestId, setReplyRequestId] = useState();
     const [confirmation, setConfirmation] = useState();
     const [statusMessage, setStatusMessage] = useState();
@@ -55,7 +65,7 @@ export function TeamThreadPage(props) {
     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)}`);
@@ -76,7 +86,7 @@ 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);
@@ -284,7 +294,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) => {
@@ -294,11 +304,24 @@ export function TeamThreadPage(props) {
         return status === undefined ? t('memberUnknown') : `@${status.member.handle}`;
     };
     const messageSender = (fact) => fact.kind === 'message' ? fact.message.sender : undefined;
+    const [pendingFiles, setPendingFiles] = useState([]);
+    // Branded-ref navigation for message bodies: channel refs hop to the
+    // Channel; the open Task's own refs are already on screen, and other Tasks
+    // are not resolvable from this surface, so they degrade to a no-op.
+    const openRef = (ref) => {
+        if (ref.startsWith('channel:') && ref !== channelRef)
+            selectChannel(ref);
+        if (ref.startsWith('task:') && ref !== taskRef) {
+            // Another Task cited here: resolve its home Channel and jump.
+            jumpToTaskThread(resolveTaskRefs, workspaceId, ref, selectThread);
+        }
+    };
+    const lookupTaskRefs = hostTaskRefLookup(resolveTaskRefs, workspaceId);
     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, attachments: fact.message.attachments, loadAttachment: getAttachment, t: t, occurredAt: fact.message.occurredAt, mentionNames: mentionNamesOf(fact.mentions, mentionHandlesMap), grouped: grouped, ...(senderStatus === undefined ? {} : { senderTitle: senderStatus.member.description }) }, factKey(fact));
+            return _jsx(TeamMessage, { senderName: sender, memberId: fact.message.sender, human: fact.message.sender === channelView?.humanMemberId, body: fact.message.body, attachments: fact.message.attachments, loadAttachment: getAttachment, t: t, occurredAt: fact.message.occurredAt, mentionNames: mentionNamesOf(fact.mentions, mentionHandlesMap), onOpenRef: openRef, onResolveTaskRefs: lookupTaskRefs, 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));
     };
@@ -354,7 +377,7 @@ export function TeamThreadPage(props) {
         setPending(true);
         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 });
@@ -395,12 +418,29 @@ export function TeamThreadPage(props) {
     const sendReply = async () => {
         if (pending || task === undefined || thread === undefined || draft.trim() === '')
             return;
-        const id = replyRequestId ?? crypto.randomUUID();
+        const id = replyRequestId ?? mintRequestId();
         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 }) });
+            // Upload chosen files first; any failure aborts the reply with the
+            // existing error surface and keeps the chips for a retry.
+            const attachmentIds = [];
+            for (const file of pendingFiles) {
+                const uploaded = await putAttachment({
+                    requestId: mintRequestId(),
+                    workspaceId,
+                    name: file.name,
+                    mediaType: file.type === '' ? undefined : file.type,
+                    bytesBase64: bytesToBase64(new Uint8Array(await file.arrayBuffer())),
+                });
+                if (!uploaded.ok) {
+                    setError(uploaded.error.message);
+                    return;
+                }
+                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 }) });
             if (!result.ok) {
                 setError(result.error.message);
                 return;
@@ -414,6 +454,7 @@ export function TeamThreadPage(props) {
                 });
                 setProjection(current => current === undefined ? current : { ...current, task: committed.task, thread: committed.thread });
                 drafts.clear(draftKey);
+                setPendingFiles([]);
                 setReplyRequestId(undefined);
                 setConfirmation(undefined);
                 setStatusMessage(undefined);
@@ -460,12 +501,28 @@ 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: [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'
+    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: [(() => {
+                                        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')
+                                            return null;
+                                        return _jsx(Button, { size: "sm", variant: "primary", disabled: pending, onClick: () => { if (earlyAccept) {
+                                                setConfirmingAccept(true);
+                                            }
+                                            else {
+                                                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 => {
+                                        : _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 && (() => {
+                        // 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))) })] });
+                    })(), 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 => { 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(); }, 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(); }, pendingFiles: pendingFiles, onFilesChange: setPendingFiles, t: t }, draftKey)) : _jsx("div", {})] });
 }

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

@@ -1,3 +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, recoverMember, restartMember, joinChannel, removeChannelMember, loadModels, openMemberSession }: TeamSidebarProps): import("react").JSX.Element;
+export declare function TeamWorkspaceBrowser({ wide, expandSidebar, navigation, selectWorkspace, selectChannel, t, useWorkspaces, loadMembers, subscribeChanges, addMember, loadChannels, createChannel, updateChannel, updateMember, recoverMember, 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

@@ -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,aAAa,EAAE,WAAW,EAAE,mBAAmB,EAAE,UAAU,EAAE,iBAAiB,EAAE,EAAE,gBAAgB,+BA4D9U"}
+{"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"}

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

@@ -5,7 +5,7 @@ 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, recoverMember, restartMember, joinChannel, removeChannelMember, loadModels, openMemberSession }) {
+export function TeamWorkspaceBrowser({ wide, expandSidebar, navigation, selectWorkspace, selectChannel, t, useWorkspaces, loadMembers, subscribeChanges, addMember, loadChannels, createChannel, updateChannel, updateMember, recoverMember, joinChannel, removeChannelMember, loadModels, openMemberSession }) {
     const navigationState = useSyncExternalStore(navigation.subscribe, navigation.getSnapshot, navigation.getSnapshot);
     const workspaces = useWorkspaces(state => state.items);
     const selected = navigationState.workspaceId;
@@ -36,5 +36,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, restartMember: restartMember, 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("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) })] })] });
 }

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;AA+BtF,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;AAuND,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.
@@ -24,7 +26,6 @@ function registerModeShadow(ctx, navigation, changes, drafts, name, component, e
         updateChannel: (request) => ctx.remote.agentTeam.updateChannel(request),
         updateMember: (request) => ctx.remote.agentTeam.updateMember(request),
         recoverMember: (request) => ctx.remote.agentTeam.recoverMember(request),
-        restartMember: (request) => ctx.remote.agentTeam.restartMember(request),
         // The Host-scoped catalog needs no live Member, so suspended ones stay editable too.
         loadModels: async () => {
             const connection = ctx.get('connection');
@@ -71,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),
+                            resolveTaskRefs: (request) => ctx.remote.agentTeam.resolveTaskRefs(request),
                         } : {}),
                         ...(name === 'sidebar.workspaces' ? {
                             addMember: (request) => ctx.remote.agentTeam.addMember(request),
@@ -93,6 +95,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 +151,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 +213,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,7 +37,6 @@ export declare const zh: {
     readonly editChannel: "编辑频道";
     readonly editAgent: "编辑 Agent";
     readonly resumeAgent: "恢复";
-    readonly restartAgent: "重启会话";
     readonly optionalSuffix: "（可选）";
     readonly agentDescriptionPlaceholder: "留空则暂无描述";
     readonly channelsPickerEmpty: "选择初始频道";
@@ -115,6 +114,10 @@ export declare const zh: {
     readonly activityClaimReleased: "{actor} 释放了「{direction}」";
     readonly activityClaimsReleased: "{actor} 因成员权限变化释放了 {count} 个 Claim";
     readonly activityAccepted: "{actor} 验收了此 Task";
+    readonly activityAcceptedWithClaims: "{actor} 验收了此 Task，并一并完成了 {count} 个未完成 Claim";
+    readonly acceptEarlyTitle: "提前验收任务";
+    readonly acceptEarlyBody: "将验收本 Task，并把以下 {count} 个未完成的 Claim 一并标记为完成：";
+    readonly acceptingTask: "验收中…";
     readonly activityClosed: "{actor} 关闭了此 Task";
     readonly activityReopened: "{actor} 重新打开了此 Task";
     readonly mentionConfirmation: "提及未关注成员需要确认，再次发送以继续";
@@ -162,7 +165,6 @@ export declare const en: {
     readonly editChannel: "Edit Channel";
     readonly editAgent: "Edit Agent";
     readonly resumeAgent: "Resume";
-    readonly restartAgent: "Restart session";
     readonly optionalSuffix: " (optional)";
     readonly agentDescriptionPlaceholder: "Leave empty if not needed";
     readonly channelsPickerEmpty: "Choose initial channels";
@@ -240,6 +242,10 @@ export declare const en: {
     readonly activityClaimReleased: "{actor} released “{direction}”";
     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 acceptEarlyTitle: "Accept Task early";
+    readonly acceptEarlyBody: "This accepts the Task and marks the following {count} unfinished Claims as done:";
+    readonly acceptingTask: "Accepting…";
     readonly activityClosed: "{actor} closed this Task";
     readonly activityReopened: "{actor} reopened this Task";
     readonly mentionConfirmation: "Mentioning an unfollowed member requires confirmation; send again to continue";

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4HL,CAAA;AAEV,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4HL,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+HL,CAAA;AAEV,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+HL,CAAA;AAEV,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,EAAE,CAAA"}

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

@@ -37,7 +37,6 @@ export const zh = {
     editChannel: '编辑频道',
     editAgent: '编辑 Agent',
     resumeAgent: '恢复',
-    restartAgent: '重启会话',
     optionalSuffix: '（可选）',
     agentDescriptionPlaceholder: '留空则暂无描述',
     channelsPickerEmpty: '选择初始频道',
@@ -115,6 +114,10 @@ export const zh = {
     activityClaimReleased: '{actor} 释放了「{direction}」',
     activityClaimsReleased: '{actor} 因成员权限变化释放了 {count} 个 Claim',
     activityAccepted: '{actor} 验收了此 Task',
+    activityAcceptedWithClaims: '{actor} 验收了此 Task，并一并完成了 {count} 个未完成 Claim',
+    acceptEarlyTitle: '提前验收任务',
+    acceptEarlyBody: '将验收本 Task，并把以下 {count} 个未完成的 Claim 一并标记为完成：',
+    acceptingTask: '验收中…',
     activityClosed: '{actor} 关闭了此 Task',
     activityReopened: '{actor} 重新打开了此 Task',
     mentionConfirmation: '提及未关注成员需要确认，再次发送以继续',
@@ -162,7 +165,6 @@ export const en = {
     editChannel: 'Edit Channel',
     editAgent: 'Edit Agent',
     resumeAgent: 'Resume',
-    restartAgent: 'Restart session',
     optionalSuffix: ' (optional)',
     agentDescriptionPlaceholder: 'Leave empty if not needed',
     channelsPickerEmpty: 'Choose initial channels',
@@ -240,6 +242,10 @@ export const en = {
     activityClaimReleased: '{actor} released “{direction}”',
     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',
+    acceptEarlyTitle: 'Accept Task early',
+    acceptEarlyBody: 'This accepts the Task and marks the following {count} unfinished Claims as done:',
+    acceptingTask: 'Accepting…',
     activityClosed: '{actor} closed this Task',
     activityReopened: '{actor} reopened this Task',
     mentionConfirmation: 'Mentioning an unfollowed member requires confirmation; send again to continue',

package/packages/client-agent-team/lib/types/client/member-session-input.d.ts

@@ -0,0 +1,22 @@
+import type { AgentTeamClientMemberStatus } from '@wowyuarm/dsh-agent-team/types';
+import type { ISession } from '@deepseek-ai/dsh-client-runtime/client';
+import type { ClientSessionContext, InputTriggerSource, SubmitOutcome } from '@deepseek-ai/dsh-client-ui-input-trigger/client';
+export declare const TEAM_COMMAND_SOURCE = "agent-team-command";
+export declare const TEAM_MEMBER_SOURCE = "agent-team-member";
+export interface TeamMemberSessionInputOptions {
+    readonly isEmbeddedMemberSession: (sessionId: ClientSessionContext['sessionId']) => boolean;
+    readonly members: () => Promise<readonly AgentTeamClientMemberStatus[]>;
+    readonly executeCompact: (sessionId: ClientSessionContext['sessionId']) => Promise<SubmitOutcome>;
+}
+/** Preserve the public Session command admission contract, not handler outcome. */
+export declare function admitTeamCompact(session: Pick<ISession, 'command'>): Promise<SubmitOutcome>;
+/**
+ * The two Team-only sources live in the shared public registry, but their
+ * candidate plane is inert for every ordinary Session. The member source owns
+ * its stable ref→label cache so serialization never falls back to guessing a
+ * handle from plain text.
+ */
+export declare function createTeamMemberSessionSources(options: TeamMemberSessionInputOptions): readonly InputTriggerSource[];
+/** Unknown leading slash must never fall into the shipped global palette. */
+export declare function allowsMemberSessionSubmit(draft: string, claimToken: string | undefined): boolean;
+//# sourceMappingURL=member-session-input.d.ts.map

package/packages/client-agent-team/lib/types/client/member-session-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"member-session-input.d.ts","sourceRoot":"","sources":["../../../src/client/member-session-input.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAqB,MAAM,gCAAgC,CAAA;AACpG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wCAAwC,CAAA;AACtE,OAAO,KAAK,EACV,oBAAoB,EAAgB,kBAAkB,EAAmB,aAAa,EACvF,MAAM,iDAAiD,CAAA;AAExD,eAAO,MAAM,mBAAmB,uBAAuB,CAAA;AACvD,eAAO,MAAM,kBAAkB,sBAAsB,CAAA;AAErD,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,uBAAuB,EAAE,CAAC,SAAS,EAAE,oBAAoB,CAAC,WAAW,CAAC,KAAK,OAAO,CAAA;IAC3F,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,SAAS,2BAA2B,EAAE,CAAC,CAAA;IACvE,QAAQ,CAAC,cAAc,EAAE,CAAC,SAAS,EAAE,oBAAoB,CAAC,WAAW,CAAC,KAAK,OAAO,CAAC,aAAa,CAAC,CAAA;CAClG;AAED,mFAAmF;AACnF,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAIjG;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,6BAA6B,GAAG,SAAS,kBAAkB,EAAE,CAiEpH;AAED,6EAA6E;AAC7E,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAGhG"}

package/packages/client-agent-team/lib/types/client/member-session-input.js

@@ -0,0 +1,98 @@
+export const TEAM_COMMAND_SOURCE = 'agent-team-command';
+export const TEAM_MEMBER_SOURCE = 'agent-team-member';
+/** Preserve the public Session command admission contract, not handler outcome. */
+export async function admitTeamCompact(session) {
+    const result = await session.command('/compact');
+    if (!result.ok)
+        throw new Error(`session.command failed: ${result.error.message}`);
+    return result.value.matched ? { kind: 'success' } : { kind: 'error', text: 'unknown command: /compact' };
+}
+/**
+ * The two Team-only sources live in the shared public registry, but their
+ * candidate plane is inert for every ordinary Session. The member source owns
+ * its stable ref→label cache so serialization never falls back to guessing a
+ * handle from plain text.
+ */
+export function createTeamMemberSessionSources(options) {
+    const labels = new Map();
+    const command = {
+        trigger: '/',
+        name: TEAM_COMMAND_SOURCE,
+        showGroupTitle: false,
+        async candidates(session, { query }) {
+            if (!options.isEmbeddedMemberSession(session.sessionId) || !'compact'.startsWith(query.toLocaleLowerCase()))
+                return [];
+            return [{ name: '/compact', description: '压缩当前 Session 上下文', value: 'compact' }];
+        },
+        onPick({ candidate, session }) {
+            if (candidate.value !== 'compact' || !options.isEmbeddedMemberSession(session.sessionId))
+                return undefined;
+            const claim = {
+                token: '/compact',
+                submit: async () => options.executeCompact(session.sessionId),
+            };
+            return { claim };
+        },
+    };
+    const member = {
+        trigger: '@',
+        name: TEAM_MEMBER_SOURCE,
+        showGroupTitle: false,
+        async candidates(session, { query, signal }) {
+            if (!options.isEmbeddedMemberSession(session.sessionId))
+                return [];
+            const normalized = query.toLocaleLowerCase();
+            const members = await options.members();
+            if (signal.aborted)
+                return [];
+            return members
+                .filter(status => status.member.sessionId !== session.sessionId && status.member.state !== 'inactive')
+                .filter(status => status.member.handle.toLocaleLowerCase().startsWith(normalized))
+                .map(status => {
+                labels.set(status.member.memberId, `@${status.member.handle}`);
+                return {
+                    name: `@${status.member.handle}`,
+                    description: '引用成员 · 不会通知',
+                    value: String(status.member.memberId),
+                };
+            });
+        },
+        onPick({ candidate, session }) {
+            if (!options.isEmbeddedMemberSession(session.sessionId) || candidate.value === undefined)
+                return undefined;
+            const ref = candidate.value;
+            const label = labels.get(ref);
+            if (label === undefined)
+                return undefined;
+            const insert = {
+                source: TEAM_MEMBER_SOURCE,
+                // The input machine retains the typed trigger; label must therefore
+                // omit `@` or the draft would become `@@handle` after insertion.
+                label: label.slice(1),
+                ref,
+                clipboardText: label,
+            };
+            return { insert };
+        },
+        codec: {
+            clipboardText: ref => labels.get(ref) ?? `@${String(ref)}`,
+            serialize: async (ref) => {
+                const stable = String(ref);
+                const label = labels.get(ref) ?? '';
+                return `<team-member ref="${escapeAttribute(stable)}">${escapeText(label)}</team-member>`;
+            },
+        },
+    };
+    return [command, member];
+}
+/** Unknown leading slash must never fall into the shipped global palette. */
+export function allowsMemberSessionSubmit(draft, claimToken) {
+    const trimmed = draft.trimStart();
+    return !trimmed.startsWith('/') || claimToken === '/compact';
+}
+function escapeText(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+}
+function escapeAttribute(value) {
+    return escapeText(value).replaceAll('"', '&quot;').replaceAll("'", '&#39;');
+}

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

@@ -0,0 +1,16 @@
+import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
+import type { AgentTeamAttachmentId, AgentTeamPutAttachmentRequest, AgentTeamPutAttachmentResult, AgentTeamRequestId } from '@wowyuarm/dsh-agent-team/types';
+/** Fresh idempotency identity for one Client-initiated durable request. */
+export declare const mintRequestId: () => AgentTeamRequestId;
+/**
+ * Upload composer files in order. One failure stops with the error text; the
+ * caller keeps its chips so a retry uploads only the still-pending files.
+ */
+export declare const uploadComposerFiles: (putAttachment: (request: AgentTeamPutAttachmentRequest) => Promise<RemoteResult<AgentTeamPutAttachmentResult>>, workspaceId: AgentTeamPutAttachmentRequest["workspaceId"], files: readonly File[]) => Promise<{
+    ok: true;
+    attachmentIds: readonly AgentTeamAttachmentId[];
+} | {
+    ok: false;
+    error: string;
+}>;
+//# sourceMappingURL=requests.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"requests.d.ts","sourceRoot":"","sources":["../../../src/client/requests.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AACpE,OAAO,KAAK,EACV,qBAAqB,EAAE,6BAA6B,EAAE,4BAA4B,EAAE,kBAAkB,EACvG,MAAM,gCAAgC,CAAA;AAGvC,2EAA2E;AAC3E,eAAO,MAAM,aAAa,QAAO,kBAA+D,CAAA;AAEhG;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAC9B,eAAe,CAAC,OAAO,EAAE,6BAA6B,KAAK,OAAO,CAAC,YAAY,CAAC,4BAA4B,CAAC,CAAC,EAC9G,aAAa,6BAA6B,CAAC,aAAa,CAAC,EACzD,OAAO,SAAS,IAAI,EAAE,KACrB,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,aAAa,EAAE,SAAS,qBAAqB,EAAE,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAatG,CAAA"}

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

@@ -0,0 +1,22 @@
+import { bytesToBase64 } from "./attachment-preview.js";
+/** Fresh idempotency identity for one Client-initiated durable request. */
+export const mintRequestId = () => crypto.randomUUID();
+/**
+ * Upload composer files in order. One failure stops with the error text; the
+ * caller keeps its chips so a retry uploads only the still-pending files.
+ */
+export const uploadComposerFiles = async (putAttachment, workspaceId, files) => {
+    const attachmentIds = [];
+    for (const file of files) {
+        const uploaded = await putAttachment({
+            requestId: mintRequestId(), workspaceId,
+            name: file.name,
+            mediaType: file.type === '' ? undefined : file.type,
+            bytesBase64: bytesToBase64(new Uint8Array(await file.arrayBuffer())),
+        });
+        if (!uploaded.ok)
+            return { ok: false, error: uploaded.error.message };
+        attachmentIds.push(uploaded.value.attachmentId);
+    }
+    return { ok: true, attachmentIds };
+};