@wowyuarm/dsh-agent-team 0.1.1 → 0.1.2

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

@@ -1,6 +1,6 @@
-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";
@@ -8,6 +8,8 @@ import { TeamRunDivider } from "./TeamRunDivider.js";
 import { formatActivity, formatClaimState, formatTaskStatus, formatTaskTitle, mentionNamesOf } from "./team-formatters.js";
 import { daySeparatorLabel, isRunGap, timelineDayKey } from "./team-separators.js";
 import { useTimelineScroll } from "./timeline-scroll.js";
+import { rememberResolvedTaskRef } 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 +32,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 +48,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();
@@ -294,11 +303,38 @@ 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.
+            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);
+            });
+        }
+    };
+    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 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));
     };
@@ -400,7 +436,24 @@ export function TeamThreadPage(props) {
         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: crypto.randomUUID(),
+                    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 +467,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 +514,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.js

@@ -24,7 +24,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 +70,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),

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/sidebar-drag.d.ts

@@ -0,0 +1,35 @@
+import type { ReactNode } from 'react';
+/** Insert side of an in-flight drop relative to the hovered row. */
+export type SidebarDropMarker = 'before' | 'after';
+export interface SidebarRowDragHandlers<K extends string> {
+    /** Per-row native wiring plus the marker this row currently shows. */
+    readonly rowProps: (orderKey: K) => {
+        readonly draggable: true;
+        readonly className?: string | undefined;
+        readonly onDragStart: (event: React.DragEvent<HTMLElement>) => void;
+        readonly onDragEnd: () => void;
+        readonly onDragOver: (event: React.DragEvent<HTMLElement>) => void;
+        readonly onDrop: (event: React.DragEvent<HTMLElement>) => void;
+    };
+}
+/**
+ * One drag gesture per panel instance. `onCommit` receives the moved ref,
+ * the drop target and the insertion side exactly once per completed gesture;
+ * releases outside the list never reach it.
+ */
+export declare function useSidebarRowDrag<K extends string>({ refs, onCommit }: {
+    /** Effective current order of the owning list, used for hit validation. */
+    readonly refs: readonly K[];
+    readonly onCommit: (movedRef: K, targetRef: K, marker: SidebarDropMarker) => void;
+}): SidebarRowDragHandlers<K>;
+/**
+ * Transparent wrapper that owns the drop-marker styling for one draggable
+ * sidebar row. It adds no layout of its own; the styled row stays inside so
+ * hover/focus descendant selectors keep working.
+ */
+export declare function SortableRow<K extends string>({ drag, orderKey, children }: {
+    readonly drag: SidebarRowDragHandlers<K>;
+    readonly orderKey: K;
+    readonly children: ReactNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=sidebar-drag.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sidebar-drag.d.ts","sourceRoot":"","sources":["../../../src/client/sidebar-drag.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAGtC,oEAAoE;AACpE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,OAAO,CAAA;AAElD,MAAM,WAAW,sBAAsB,CAAC,CAAC,SAAS,MAAM;IACtD,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK;QAClC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAA;QACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QACvC,QAAQ,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,WAAW,CAAC,KAAK,IAAI,CAAA;QACnE,QAAQ,CAAC,SAAS,EAAE,MAAM,IAAI,CAAA;QAC9B,QAAQ,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,WAAW,CAAC,KAAK,IAAI,CAAA;QAClE,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,WAAW,CAAC,KAAK,IAAI,CAAA;KAC/D,CAAA;CACF;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;IACtE,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,CAAA;IAC3B,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,iBAAiB,KAAK,IAAI,CAAA;CAClF,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAwC5B;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE;IAC1E,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC,CAAC,CAAC,CAAA;IACxC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAA;IACpB,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAA;CAC7B,+BAOA"}

package/packages/client-agent-team/lib/types/client/sidebar-drag.js

@@ -0,0 +1,70 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Native whole-row drag for the Team sidebar lists. Unlike the Harness
+ * workspace list there is no document-level acceptance here: hovering another
+ * row shows the before/after insertion marker and releasing on a row commits
+ * exactly once per gesture, while a release outside any row — including over
+ * the other sidebar list, whose panel never responds — just cancels without
+ * committing.
+ */
+import { useRef, useState } from 'react';
+import css from './sidebar.module.css';
+/**
+ * One drag gesture per panel instance. `onCommit` receives the moved ref,
+ * the drop target and the insertion side exactly once per completed gesture;
+ * releases outside the list never reach it.
+ */
+export function useSidebarRowDrag({ refs, onCommit }) {
+    const [state, setState] = useState(null);
+    const committed = useRef(false);
+    const half = (event) => {
+        const rect = event.currentTarget.getBoundingClientRect();
+        return event.clientY - rect.top < rect.height / 2 ? 'before' : 'after';
+    };
+    return {
+        rowProps: orderKey => ({
+            draggable: true,
+            className: state === null ? undefined
+                : state.active === orderKey ? css.sidebarRowDragging
+                    : state.over === orderKey ? (state.marker === 'before' ? css.sidebarRowDropBefore : css.sidebarRowDropAfter)
+                        : undefined,
+            onDragStart: event => {
+                if (event.dataTransfer === null)
+                    return;
+                event.dataTransfer.effectAllowed = 'move';
+                event.dataTransfer.setData('text/plain', orderKey);
+                committed.current = false;
+                setState({ active: orderKey, over: orderKey, marker: 'after' });
+            },
+            onDragEnd: () => { setState(null); },
+            onDragOver: event => {
+                if (state === null || !refs.includes(orderKey))
+                    return;
+                event.preventDefault();
+                if (event.dataTransfer !== null)
+                    event.dataTransfer.dropEffect = 'move';
+                const marker = half(event);
+                if (state.over !== orderKey || state.marker !== marker)
+                    setState({ ...state, over: orderKey, marker });
+            },
+            onDrop: event => {
+                if (state === null || !refs.includes(orderKey))
+                    return;
+                event.preventDefault();
+                if (committed.current)
+                    return;
+                committed.current = true;
+                onCommit(state.active, orderKey, half(event));
+            },
+        }),
+    };
+}
+/**
+ * Transparent wrapper that owns the drop-marker styling for one draggable
+ * sidebar row. It adds no layout of its own; the styled row stays inside so
+ * hover/focus descendant selectors keep working.
+ */
+export function SortableRow({ drag, orderKey, children }) {
+    const props = drag.rowProps(orderKey);
+    return (_jsx("div", { ...props, children: children }));
+}

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

@@ -0,0 +1,27 @@
+import type { WorkspaceId } from '@deepseek-ai/dsh-client-runtime/client';
+/** Which sidebar list an order belongs to; the two ledgers are independent. */
+export type TeamSidebarListKind = 'channels' | 'agents';
+/** Insert side of a drop relative to the row under the pointer. */
+export type SidebarDropMarker = 'before' | 'after';
+/**
+ * Merge the saved personal order into the current Remote order: kept refs
+ * stay in the user's relative order with duplicates collapsed, removed refs
+ * disappear, and new refs join in their Remote default positions after the
+ * known ones.
+ */
+export declare function reconcileSidebarOrder<R extends string>(saved: readonly string[], current: readonly R[]): readonly R[];
+/**
+ * Effective row order for one sidebar list: the user's saved order folded
+ * into the given Remote default order. Identity-stable across renders while
+ * neither the data nor this browser's preference changes.
+ */
+export declare function useSidebarOrder<R extends string>(workspaceId: WorkspaceId | undefined, kind: TeamSidebarListKind, refs: readonly R[]): readonly R[];
+/**
+ * The only mutation path: move `movedRef` to the given side of `targetRef`
+ * inside the list's current effective order. Returns the new order, or
+ * `undefined` when the request cannot change anything (unknown refs, dropping
+ * a row onto itself, or an adjacent marker that would put it right back).
+ * Persistence and subscriber notification happen here.
+ */
+export declare function moveSidebarItem<R extends string>(workspaceId: WorkspaceId | undefined, kind: TeamSidebarListKind, refs: readonly R[], movedRef: R, targetRef: R, marker: SidebarDropMarker): readonly R[] | undefined;
+//# sourceMappingURL=sidebar-order.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sidebar-order.d.ts","sourceRoot":"","sources":["../../../src/client/sidebar-order.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAA;AAEzE,+EAA+E;AAC/E,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,QAAQ,CAAA;AAEvD,mEAAmE;AACnE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,OAAO,CAAA;AA2ElD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,GAAG,SAAS,CAAC,EAAE,CAerH;AAqCD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,WAAW,EAAE,WAAW,GAAG,SAAS,EAAE,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,GAAG,SAAS,CAAC,EAAE,CAQnJ;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAC9C,WAAW,EAAE,WAAW,GAAG,SAAS,EACpC,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,QAAQ,EAAE,CAAC,EACX,SAAS,EAAE,CAAC,EACZ,MAAM,EAAE,iBAAiB,GACxB,SAAS,CAAC,EAAE,GAAG,SAAS,CAe1B"}

package/packages/client-agent-team/lib/types/client/sidebar-order.js

@@ -0,0 +1,170 @@
+/**
+ * Human presentation preference for the Team sidebar: the row order of the
+ * Channels and Agents lists. The order lives in this browser only — it is UI
+ * taste, never a shared Team fact, so nothing here touches the ledger.
+ *
+ * One deep module owns the whole concern: storage, reconcile against the
+ * current Remote order (drop removed refs, keep the user's relative order,
+ * append newcomers in default order), the single `moveSidebarItem` mutation
+ * behind whole-row drag, and a small subscription hook with snapshot-stable
+ * results for `useSyncExternalStore`.
+ */
+import { useCallback, useSyncExternalStore } from 'react';
+const STORAGE_KEY = 'dsh.agent-team.sidebar-order';
+function listKey(workspaceId, kind) {
+    return workspaceId === undefined ? undefined : `${workspaceId}|${kind}`;
+}
+const MEMORY_ONLY = Symbol('sidebar-order.memory');
+/**
+ * Read-through parse cache over the raw persisted payload: repeated snapshots
+ * skip re-validating an unchanged payload, while anything written outside this
+ * module — another tab, devtools, a cleared store — is picked up because the
+ * raw comparison misses.
+ */
+let cachedRaw;
+let cachedOrders = {};
+/**
+ * Parse persisted orders defensively: private mode, quota errors, and stale
+ * or corrupted payloads all degrade to "no preference" instead of breaking
+ * the sidebar.
+ */
+function storedOrders() {
+    let raw = null;
+    try {
+        raw = typeof localStorage === 'undefined' ? null : localStorage.getItem(STORAGE_KEY);
+    }
+    catch {
+        raw = null;
+    }
+    if (cachedRaw !== undefined && raw !== null && raw === cachedRaw)
+        return cachedOrders;
+    if (raw === null) {
+        if (cachedRaw === MEMORY_ONLY)
+            return cachedOrders;
+        cachedRaw = raw;
+        cachedOrders = {};
+        return cachedOrders;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+            throw new Error('not an object');
+        const clean = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (!Array.isArray(value) || !value.every(entry => typeof entry === 'string'))
+                continue;
+            clean[key] = value;
+        }
+        cachedRaw = raw;
+        cachedOrders = clean;
+        return cachedOrders;
+    }
+    catch {
+        return {};
+    }
+}
+function saveOrder(key, refs) {
+    const next = { ...structuredClone(storedOrders()), [key]: refs };
+    cachedOrders = next;
+    try {
+        if (typeof localStorage !== 'undefined') {
+            const raw = JSON.stringify(next);
+            localStorage.setItem(STORAGE_KEY, raw);
+            cachedRaw = raw;
+            return;
+        }
+    }
+    catch {
+        // Private mode and quota failures do not block reordering; the session
+        // keeps serving the in-memory order below.
+    }
+    cachedRaw = MEMORY_ONLY;
+}
+/**
+ * Merge the saved personal order into the current Remote order: kept refs
+ * stay in the user's relative order with duplicates collapsed, removed refs
+ * disappear, and new refs join in their Remote default positions after the
+ * known ones.
+ */
+export function reconcileSidebarOrder(saved, current) {
+    const present = new Set(current);
+    const seen = new Set();
+    const merged = [];
+    for (const ref of saved) {
+        if (seen.has(ref) || !present.has(ref))
+            continue;
+        seen.add(ref);
+        merged.push(ref);
+    }
+    for (const ref of current) {
+        if (seen.has(ref))
+            continue;
+        seen.add(ref);
+        merged.push(ref);
+    }
+    return merged;
+}
+let revision = 0;
+const listeners = new Set();
+const snapshots = new Map();
+function savedFingerprint(key) {
+    const saved = storedOrders()[key];
+    return saved === undefined ? '' : `f${saved.length}:${saved.join(',')}`;
+}
+function emitChange() {
+    revision += 1;
+    for (const listener of listeners)
+        listener();
+}
+function orderedSnapshot(workspaceId, kind, refs) {
+    const key = listKey(workspaceId, kind);
+    if (key === undefined)
+        return refs;
+    const signature = refs.join('\u0000');
+    const fingerprint = savedFingerprint(key);
+    const hit = snapshots.get(key);
+    if (hit !== undefined && hit.atRevision === revision && hit.signature === signature && hit.savedFingerprint === fingerprint) {
+        return hit.result;
+    }
+    const result = reconcileSidebarOrder(storedOrders()[key] ?? [], refs);
+    snapshots.set(key, { atRevision: revision, signature, savedFingerprint: fingerprint, result });
+    return result;
+}
+/**
+ * Effective row order for one sidebar list: the user's saved order folded
+ * into the given Remote default order. Identity-stable across renders while
+ * neither the data nor this browser's preference changes.
+ */
+export function useSidebarOrder(workspaceId, kind, refs) {
+    const subscribe = useCallback((listener) => {
+        listeners.add(listener);
+        return () => { listeners.delete(listener); };
+    }, []);
+    return useSyncExternalStore(subscribe, () => orderedSnapshot(workspaceId, kind, refs), () => orderedSnapshot(workspaceId, kind, refs));
+}
+/**
+ * The only mutation path: move `movedRef` to the given side of `targetRef`
+ * inside the list's current effective order. Returns the new order, or
+ * `undefined` when the request cannot change anything (unknown refs, dropping
+ * a row onto itself, or an adjacent marker that would put it right back).
+ * Persistence and subscriber notification happen here.
+ */
+export function moveSidebarItem(workspaceId, kind, refs, movedRef, targetRef, marker) {
+    const key = listKey(workspaceId, kind);
+    const from = refs.indexOf(movedRef);
+    const nextFromTarget = refs.indexOf(targetRef);
+    if (key === undefined || from < 0 || nextFromTarget < 0 || movedRef === targetRef)
+        return undefined;
+    const next = [...refs];
+    const [item] = next.splice(from, 1);
+    if (item === undefined)
+        return undefined;
+    const insertAt = next.indexOf(targetRef) + (marker === 'after' ? 1 : 0);
+    if (insertAt === from)
+        return undefined;
+    next.splice(insertAt, 0, item);
+    saveOrder(key, next);
+    snapshots.delete(key);
+    emitChange();
+    return next;
+}