@deepseek-ai/dsh-client-ui-workspace 0.1.5-rc.2 → 0.1.6-alpha.1

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/client/ui-workspace/README.md
-README.md: 857b38c2ca08ca4e9078d8f9dfcfe8462be50722
-README.zh.md: cf6f2d273f00add793cc5ac588db968c22007256
+README.md: 1edf9223c72e7094ce305734119975c3954cce59
+README.zh.md: 122f1d97a5a4dd7c5b54b0d9a27e323cdc6fb8ca

package/README.md

@@ -29,7 +29,7 @@ Use the sidebar to browse Workspaces and their Sessions, reorder them, and start
 
 ### Reordering and view options
 
-View options combine grouping with one browser-persisted Session order per account: **Manual** and **Last updated** apply in either presentation. Entering Last updated performs a complete recency sort and later user prompts or steers promote their Session once; entering Manual preserves every current position and disables later promotion. Dragging edits the current order in either mode; Manual-mode drags for real Workspaces also update the Host Session account, while Ungrouped and flat-list orders remain browser-local. In a collapsed group, drag boundaries follow rendered rows and place the source before intervening hidden rows, so a drag cannot hide its source. Workspace drag order is Host-durable in either Session order mode.
+**Last updated** orders ordinary Sessions by their latest user prompt or steer time, newest first, in both grouped and flat views. **Manual** freezes the current displayed order and holds positions when activity changes; newly discovered ordinary Sessions append to the end, newest first when several arrive together. Returning to Last updated discards every manual position, and entering Manual again freezes the then-current recency order. The browser defaults to Last updated and remembers the selected mode across reloads. Dragging an ordinary Session applies the move locally and selects Manual. The selected blank **New Session** is always pinned first and cannot be dragged; after its first prompt it becomes an ordinary draggable row, retaining its first position in Manual or following its current timestamp in Last updated. In a collapsed group, drag boundaries follow rendered rows and place the source before intervening hidden rows, so a drag cannot hide its source. Session display orders for real Workspaces, Ungrouped, and the flat list are browser-local; Workspace group drag order remains Host-durable.
 
 ### Search
 
@@ -67,7 +67,7 @@ Each registration declares a **directory-flow child hole** (`single` kind: `conv
 
 ### View state
 
-Once the Workspace list baseline is ready, browser-persisted expansion and Session-order records retain only current Workspace ids plus Ungrouped and the flat-list account. Real Workspaces initialize from `WorkspaceView.sessionIds`, while Ungrouped and the cross-Workspace flat list initialize from recency. The shared sidebar projection hides rows whose durable Session summary has `origin: 'subagent'`, and each visible ordinary row inherits the blue activity indicator while any descendant reached through uninterrupted subagent-origin lineage is running. The same pure derivation reads the Schedule key from list projection values for grouped, flat, and search nodes; the package uses only the type-only `@deepseek-ai/dsh-schedule/client` dependency and does not import the Schedule runtime or `ui-schedule`.
+Once the Workspace list baseline is ready, browser-persisted expansion and manual Session-order records retain only current Workspace ids plus Ungrouped and the flat-list account. `WorkspaceView.sessionIds` supplies real-Workspace membership, not Session display order. View actions require the current account orders explicitly. Flat-list membership and ordering use Session ids; row rendering adds status indicators once. Entering Manual snapshots every active account from the current display; reconciliation retains saved members that still belong to the account, removes departed members, and appends newly known members by recency. A new membership entry without a Session summary is omitted until that summary arrives, while an already saved slot survives a temporarily missing summary. During Workspace reconnection, Manual records an observed blank Session at the front of its saved flat and known group orders without removing other saved members; full membership reconciliation waits for the Workspace baseline. This reconciliation remains mounted while the sidebar is a rail or search replaces its body. Last updated derives directly from each current list snapshot without reading or writing saved positions; equal timestamps use Session ids as a stable tie-break. The shared sidebar projection hides rows whose durable Session summary has `origin: 'subagent'`, and each visible ordinary row inherits the blue activity indicator while any descendant reached through uninterrupted subagent-origin lineage is running. The same pure derivation reads the Schedule key from list projection values for grouped, flat, and search nodes; the package uses only the type-only `@deepseek-ai/dsh-schedule/client` dependency and does not import the Schedule runtime or `ui-schedule`.
 
 ### Hover cards
 
@@ -85,7 +85,7 @@ These pages cover the sidebar host, the hero surface, and the picking backends.
 - [ui-sidebar](../ui-sidebar/README.md) — the sidebar shell hosting the `sidebar.workspaces` hole.
 - [ui-conversation](../ui-conversation/README.md) — the chat surface hosting the Session Intent hero's picker hole.
 - [directory-picker-native](../../host/directory-picker-native/README.md) — the OS-chooser backend filling the directory-flow hole.
-- [Workspace Controller](../../api/workspace-controller/README.md) — the Host mutations and framework-neutral Client projection that own workspaces and ordering.
+- [Workspace Controller](../../api/workspace-controller/README.md) — the Host mutations and framework-neutral Client projection that own Workspaces, membership, and Workspace group order.
 
 -----
 
@@ -106,7 +106,7 @@ None; this package neither assembles nor sends a provider request.
 These limits define the search depth, the archive surface, and the picking carrier; they are current package constraints.
 
 - **No fuzzy content search or event deep links** — the content backend uses literal token/phrase matching, and selecting a result opens the Session rather than the matching event.
-- **No Session deletion or unarchive control** — sessions can be archived, but archived sessions have no viewing or unarchive surface, and Workspace registration deletion does not delete Sessions.
+- **No Session deletion, and unarchive lives in Settings** — sessions can be archived but never deleted; the archived-sessions Settings page ([ui-settings-unarchive-sessions](../ui-settings-unarchive-sessions/README.md)) owns viewing and restoring them, and Workspace registration deletion does not delete Sessions.
 - **Pending user interaction is not aggregated into collapsed groups** — a waiting row inside a collapsed group lights no group-header indicator and becomes visible only after that group is expanded.
 - **Native folder selection depends on the local Host carrier** — under the `-native` composition, in-process or remote browser deployments cannot open a local operating-system dialog; remote-capable picking is the `-browse` composition's in-app flow.
 
@@ -120,4 +120,4 @@ None.
 
 </details>
 
-**Runtime invariant:** No companion is published. A pure-consumer plugin registering presentational components into two host-declared slots plus its locale dictionaries — its inject face is stateless RPC wrappers plus a create-and-open call; it emits no cordis events and owns no cross-plugin mutable state.
+**Runtime invariant:** No companion is published. This is a pure-consumer plugin that registers presentational components into two host-declared slots and registers its locale dictionaries; its inject face consists of stateless RPC wrappers plus a create-and-open call. It emits no Cordis events and owns no cross-plugin mutable state.

package/README.zh.md

@@ -1,5 +1,5 @@
 ---
-description: "dsh Web 客户端的共享 Workspace 浏览器与选择器插件：分组或扁平的会话行、添加/重命名/重排序、搜索、fork、归档，以及目录流选取子 slot。"
+description: "dsh Web 客户端的共享 Workspace 浏览器与选择器插件：分组或扁平的会话行、添加、重命名、重排序、搜索、fork、归档，以及目录流选取子 slot。"
 kind: "package-reference"
 ---
 
@@ -29,7 +29,7 @@ kind: "package-reference"
 
 ### 重排序与视图选项
 
-视图选项把分组方式和每个记账各自的一份浏览器持久化 Session 顺序放在一起：**手动排序**和**最近更新**在两种呈现方式下都可用。进入最近更新时会执行一次完整的时间排序，后续 user prompt 或 steer 会将对应 Session 置顶一次；进入手动排序则保留所有当前位置并停用后续置顶。两种模式下的拖拽都会编辑当前顺序；真实 Workspace 在手动模式下的拖拽还会更新 Host Session 记账，而 Ungrouped 和单列表的顺序始终只保存在浏览器本地。折叠分组的拖拽边界按渲染行确定，并把来源行放在中间隐藏行之前，因此拖拽不会隐藏来源行。无论采用哪种 Session 顺序，Workspace 拖拽顺序都由 Host 持久化。
+**最近更新**在分组和单列表视图中都按普通 Session 的最近一次用户提示词或 steering（中途引导）时间降序排列。**手动排序**会冻结当前显示顺序，并在活动变化时保持已有位置；新发现的普通 Session 追加到末尾，多条同时到达时按最近更新时间降序排列。返回最近更新会丢弃所有手动位置；再次进入手动排序时，则冻结当时的最近更新顺序。浏览器默认采用最近更新，并在重新加载后记住所选模式。拖拽普通 Session 会在浏览器本地应用移动并选中手动排序。当前选中的空白**新会话**始终固定在首位且无法拖拽；首条提示词落地后，它成为可拖拽的普通行，在手动排序中保留首位，在最近更新中按当前时间戳排列。折叠分组的拖拽边界按渲染行确定，并把来源行放在中间隐藏行之前，因此拖拽不会隐藏来源行。真实 Workspace、Ungrouped 与单列表的 Session 显示顺序都保留在浏览器本地；Workspace 分组的拖拽顺序仍由 Host 持久化。
 
 ### 搜索
 
@@ -45,13 +45,13 @@ Session 行渲染运行时的实时 `pendingInteraction` 分类：审批显示**
 
 ### 活动 Schedule 标识
 
-分组与平铺 Session 行以及搜索结果会在 `SessionSummary.projectionValues.schedule` 为非空数组时显示一枚轮廓闹钟。标识位于标题之后；普通行的更新时间仍位于标识之后，搜索结果则没有更新时间。它不是按钮，没有独立 pointer 行为或 Tab stop，点击所在区域仍会打开整行。本地化 tooltip 与同义读屏标签均为**有活动定时任务**。
+分组与平铺 Session 行以及搜索结果会在 `SessionSummary.projectionValues.schedule` 为非空数组时显示一枚轮廓闹钟。标识位于标题之后；普通行的更新时间仍位于标识之后，搜索结果则没有更新时间。它不是按钮，没有独立 pointer 行为或 Tab stop，点击所在区域仍会打开整行。本地化 tooltip 与文本相同的读屏标签均为**有活动定时任务**。
 
-对于 cold Session，该值有意采用尽力而为语义。身份匹配且可用的 projection-cache 行可以在不打开 Session 的情况下预热闹钟；cache 缺失或陈旧可能造成短暂漏显或残留。标识只表示当前列表值包含尚未 dispatch 或 delete 的 Schedule 记录，不表示 Schedule runtime 当前 live 或能够唤醒该 Session。
+对于 cold Session，该值有意采用尽力而为语义。身份匹配且可用的 projection-cache 行可以在不打开 Session 的情况下预热闹钟；cache 缺失或陈旧可能造成短暂漏显或残留。标识只表示当前列表值包含尚未 dispatch 或 delete 的 Schedule 记录，不表示 Schedule 运行时当前 live 或能够唤醒该 Session。
 
 -----
 
-`ctx.uiWorkspace.openSession(id)` 将选中会话与中央区域返回会话界面作为一次 UI 导航操作，包括目标会话已经是当前会话的情况。`openWorkspace(id, beforeOpen?)` 和 `forkSession(id)` 仅在请求未被后续导航替代时打开结果；新会话使用 `openWorkspace`。可选的同步准备回调仅对仍有效的工作区请求执行，因此过期请求不会搬移 composer 草稿。后续导航或所有者释放会阻止晚到的 UI 提交，但不取消底层会话创建。选中失败时保留当前全局面板。会话行读取 `usePanelInfo`，在全局面板活跃时不显示会话选中样式；仅把焦点移到搜索框或目录选择器不会离开该面板。
+`ctx.uiWorkspace.openSession(id)` 会选中会话，并让主区域返回会话界面；这两项构成一次 UI 导航操作，即使目标会话已经是当前会话也同样执行。`openWorkspace(id, beforeOpen?)` 和 `forkSession(id)` 仅在请求未被后续导航替代时打开结果；新会话使用 `openWorkspace`。可选的同步准备回调仅对仍有效的工作区请求执行，因此过期请求不会搬移 composer 草稿。后续导航或所有者释放会阻止晚到的 UI 提交，但不取消底层会话创建。选中失败时保留当前全局面板。会话行读取 `usePanelInfo`，在全局面板活跃时不显示会话选中样式；仅把焦点移到搜索框或目录选择器不会离开该面板。
 
 <a id="understand-the-implementation"></a>
 ## 理解实现
@@ -67,7 +67,7 @@ Session 行渲染运行时的实时 `pendingInteraction` 分类：审批显示**
 
 ### 视图状态
 
-Workspace 列表基线就绪后，浏览器持久化的展开状态与 Session 顺序记录只保留当前 Workspace id、Ungrouped 与单列表记账。真实 Workspace 从 `WorkspaceView.sessionIds` 初始化，Ungrouped 与跨 Workspace 单列表从最近更新时间顺序初始化。共享侧边栏投影会隐藏持久化 Session 摘要中带有 `origin: 'subagent'` 的行；每个可见普通行都会在经不间断的 subagent 谱系可达的任一后代运行时继承蓝色活动指示器。同一份纯派生还会为分组、平铺与搜索节点读取列表 projection value 中的 Schedule key；本包只使用纯类型依赖 `@deepseek-ai/dsh-schedule/client`，不会导入 Schedule runtime 或 `ui-schedule`。
+Workspace 列表基线就绪后，浏览器持久化的展开状态和手动 Session 顺序记录只保留当前 Workspace id、Ungrouped 和单列表记账。`WorkspaceView.sessionIds` 提供真实 Workspace 的成员关系，而不提供 Session 显示顺序。视图操作要求显式传入当前各记账的顺序。单列表的成员筛选和排序使用 Session id，行渲染只计算一次状态指示。进入手动排序会从当前显示结果一次性记录每个有效记账；对账会保留仍属于该记账的已保存成员、移除已经离开的成员，并按最近更新时间追加新发现的成员。尚无 Session 摘要的新成员会等摘要到达后再加入，而已经保存的位置在摘要暂时缺失时仍会保留。Workspace 重连期间，手动排序会将已观察到的空白 Session 记录到已保存的单列表及已知分组顺序首位，不移除其他已保存成员；完整成员对账等待 Workspace 基线到齐。即使侧边栏收成窄栏或搜索替代列表主体，这项对账也保持挂载。最近更新直接从每份当前列表快照派生，不读取或写入已保存位置；时间相同时按 Session id 稳定排序。共享侧边栏投影会隐藏持久化 Session 摘要中带有 `origin: 'subagent'` 的行；每个可见普通行都会在经不间断的 subagent 谱系可达的任一后代运行时继承蓝色活动指示器。同一项纯派生逻辑还会为分组、平铺与搜索节点读取列表 projection value 中的 Schedule key；本包只使用纯类型依赖 `@deepseek-ai/dsh-schedule/client`，不会导入 Schedule 运行时或 `ui-schedule`。
 
 ### 悬浮卡片
 
@@ -85,7 +85,7 @@ Workspace 与 Session 悬浮卡片会复制对应行被截断的值：激活 Wor
 - [ui-sidebar](../ui-sidebar/README.zh.md)——承载 `sidebar.workspaces` 子 slot 的侧边栏外壳。
 - [ui-conversation](../ui-conversation/README.zh.md)——承载 Session Intent 主视觉区选择器子 slot 的聊天界面。
 - [directory-picker-native](../../host/directory-picker-native/README.zh.md)——填充目录流子 slot 的 OS 选择器后端。
-- [Workspace Controller](../../api/workspace-controller/README.zh.md)——负责 Workspace 与排序的 Host 变更和框架无关 Client 投影。
+- [Workspace Controller](../../api/workspace-controller/README.zh.md)——负责 Workspace、成员关系与 Workspace 分组顺序的 Host 变更和框架无关 Client 投影。
 
 -----
 
@@ -106,7 +106,7 @@ Workspace 与 Session 悬浮卡片会复制对应行被截断的值：激活 Wor
 这些限制定义搜索深度、归档界面与选取载体；它们是当前包约束。
 
 - **没有模糊内容搜索或事件深链接**：内容后端采用字面 token/短语匹配，选择结果会打开 Session，而不是匹配的事件。
-- **没有 Session 删除与取消归档控件**：会话可以归档，但已归档会话没有查看或取消归档入口；删除 Workspace 注册记录不会删除 Session。
+- **没有 Session 删除，取消归档位于设置中**：会话可以归档但绝不会被删除；已归档会话的查看与恢复由「已归档会话」设置页（[ui-settings-unarchive-sessions](../ui-settings-unarchive-sessions/README.zh.md)）负责，删除 Workspace 注册记录不会删除 Session。
 - **待处理的用户交互不会聚合到折叠的分组上**：折叠分组内正在等待的行不会点亮分组头指示，只有展开该分组后才可见。
 - **原生文件夹选择依赖本地 Host 载体**：在 `-native` 组合下，进程内部署或远程浏览器部署无法打开本地操作系统对话框；可远程的选取是 `-browse` 组合的应用内流程。
 
@@ -120,4 +120,4 @@ Workspace 与 Session 悬浮卡片会复制对应行被截断的值：激活 Wor
 
 </details>
 
-**运行时不变式：** 不发布伴生入口。这是纯消费插件，只注册展示组件和 locale dictionary；inject face 是无状态 RPC wrapper 加 create-and-open 调用，不发出事件或持有跨插件可变状态。
+**运行时不变式：** 不发布伴生入口。这是一个纯消费方插件，只向两个由宿主声明的 slot 注册展示组件，并注册自身的 locale dictionaries；inject face 由无状态 RPC 包装层和一次 create-and-open 调用组成；本插件不发出 Cordis 事件，也不持有跨插件可变状态。

package/lib/client.js

@@ -97,6 +97,9 @@ window.__ModuleLoader__.load({
 			async archiveSession(sessionId) {
 				await this.workspaces.archiveSession(sessionId);
 			}
+			async unarchiveSession(sessionId) {
+				await this.workspaces.unarchiveSession(sessionId);
+			}
 			async pickDirectory() {
 				const result = await this.directoryPicker.pick();
 				if (!result.ok) throw new Error(`directory picker failed: ${result.error.message}`);
@@ -187,6 +190,10 @@ window.__ModuleLoader__.load({
 		*/
 		/** Browser-local order account for the hierarchy-free flat Session list. */
 		const FLAT_SESSION_ORDER_KEY = "__flat_session_order__";
+		/** Copy read-only projections into the persisted mutable store representation. */
+		function copySessionOrders(orders) {
+			return Object.fromEntries(Object.entries(orders).map(([key, order]) => [key, [...order]]));
+		}
 		/**
 		* Create the workspace browser viewing store handle.
 		* @returns the store handle (spec + type + identity + factory in one).
@@ -197,15 +204,16 @@ window.__ModuleLoader__.load({
 					groupBy: "workspace",
 					orderBy: "updated",
 					groupExpansion: {},
-					sessionOrderByAccount: {},
-					sessionUpdatedAtByAccount: {}
+					sessionOrderByAccount: {}
 				}),
 				persist: "dsh.workspace.view.v5",
 				actions: {
 					setGroupBy: (d, mode) => {
 						d.groupBy = mode;
 					},
-					setOrderBy: (d, mode) => {
+					setOrderBy: (d, mode, initialOrders) => {
+						if (mode === d.orderBy) return;
+						d.sessionOrderByAccount = mode === "manual" ? copySessionOrders(initialOrders) : {};
 						d.orderBy = mode;
 					},
 					setGroupExpanded: (d, key, expanded) => {
@@ -215,14 +223,16 @@ window.__ModuleLoader__.load({
 						const retained = new Set(workspaceKeys);
 						d.groupExpansion = Object.fromEntries(Object.entries(d.groupExpansion).filter(([key]) => retained.has(key)));
 						d.sessionOrderByAccount = Object.fromEntries(Object.entries(d.sessionOrderByAccount).filter(([key]) => retained.has(key)));
-						d.sessionUpdatedAtByAccount = Object.fromEntries(Object.entries(d.sessionUpdatedAtByAccount).filter(([key]) => retained.has(key)));
+						delete d.sessionUpdatedAtByAccount;
 					},
-					syncSessionOrderAccount: (d, accountKey, order, updatedAt) => {
-						d.sessionOrderByAccount[accountKey] = order;
-						d.sessionUpdatedAtByAccount[accountKey] = updatedAt;
+					syncSessionOrders: (d, orders) => {
+						if (d.orderBy !== "manual") return;
+						Object.assign(d.sessionOrderByAccount, copySessionOrders(orders));
 					},
-					setSessionOrder: (d, accountKey, order) => {
-						d.sessionOrderByAccount[accountKey] = order;
+					setSessionOrder: (d, accountKey, order, initialOrders) => {
+						if (d.orderBy === "updated") d.sessionOrderByAccount = copySessionOrders(initialOrders);
+						d.orderBy = "manual";
+						d.sessionOrderByAccount[accountKey] = [...order];
 					}
 				}
 			});
@@ -324,10 +334,57 @@ window.__ModuleLoader__.load({
 			const base = workspaceTitleOf(cwd);
 			return base !== "" ? base : cwd;
 		}
-		/** Recency comparator: newest first, id as the deterministic tiebreak (ids are unique per group). */
-		function byRecency(a, b) {
-			if (b.updatedAt !== a.updatedAt) return b.updatedAt - a.updatedAt;
-			return a.id < b.id ? -1 : 1;
+		/**
+		* Project known account members by current Session recency.
+		* @param sessionIds - authoritative account membership.
+		* @param summaries - current Session summaries; members without a summary are omitted until it arrives.
+		* @returns known members newest first, with Session identity as the deterministic tie-break.
+		*/
+		function orderByRecency(sessionIds, summaries) {
+			return sessionIds.flatMap((id) => {
+				const summary = summaries[id];
+				return summary === void 0 ? [] : [{
+					id,
+					updatedAt: summary.updatedAt
+				}];
+			}).sort((a, b) => {
+				if (a.updatedAt !== b.updatedAt) return b.updatedAt - a.updatedAt;
+				return a.id < b.id ? -1 : 1;
+			}).map((member) => member.id);
+		}
+		/**
+		* Reconcile a browser-local manual order with current account membership.
+		* @param memberIds - authoritative account membership.
+		* @param savedOrder - previously saved browser-local order.
+		* @param summaries - current Session summaries used to append newly known members by recency.
+		* @returns retained saved slots followed by newly known members; departed members and unknown new members are omitted.
+		*/
+		function reconcileManualOrder(memberIds, savedOrder, summaries) {
+			const members = new Map(memberIds.map((id) => [id, id]));
+			const included = /* @__PURE__ */ new Set();
+			const ordered = [];
+			for (const key of savedOrder ?? []) {
+				const id = members.get(key);
+				if (id === void 0 || included.has(key)) continue;
+				ordered.push(id);
+				included.add(key);
+			}
+			for (const id of orderByRecency(memberIds, summaries)) {
+				if (included.has(id)) continue;
+				ordered.push(id);
+				included.add(id);
+			}
+			return ordered;
+		}
+		/**
+		* Keep the selected provisional New Session ahead of either base order.
+		* @param order - recency or reconciled manual order.
+		* @param currentBlank - selected blank Session in this account, when present.
+		* @returns a copy with the selected blank first and no duplicate slot.
+		*/
+		function pinCurrentBlank(order, currentBlank) {
+			if (currentBlank === void 0) return [...order];
+			return [currentBlank, ...order.filter((id) => id !== currentBlank)];
 		}
 		/**
 		* Ordinary sessions are visible; among blank sessions, only the current one
@@ -351,40 +408,30 @@ window.__ModuleLoader__.load({
 			return (session.projectionValues?.schedule?.length ?? 0) > 0;
 		}
 		/** Build one group without projecting session lineage into presentation. */
-		function buildGroup(key, workspaceId, cwd, createdAt, label, members, order) {
-			const sessions = [...members];
-			if (order === "recency") sessions.sort(byRecency);
+		function buildGroup(key, workspaceId, cwd, createdAt, label, members) {
 			return {
 				key,
 				workspaceId,
 				cwd,
 				createdAt,
 				label,
-				sessions
+				sessions: [...members]
 			};
 		}
 		/** Apply a stored Ungrouped order and append newly loose Sessions by recency. */
-		function orderedUngrouped(members, stored) {
+		function orderedUngrouped(members, stored, summaries) {
 			const byId = new Map(members.map((session) => [session.id, session]));
-			const included = /* @__PURE__ */ new Set();
-			const ordered = [];
-			for (const key of stored) {
-				const session = byId.get(key);
-				if (session === void 0 || included.has(key)) continue;
-				ordered.push(session);
-				included.add(key);
-			}
-			for (const session of [...members].sort(byRecency)) {
-				if (included.has(session.id)) continue;
-				ordered.push(session);
-			}
-			return ordered;
+			return (stored === void 0 ? orderByRecency(members.map((session) => session.id), summaries) : reconcileManualOrder(members.map((session) => session.id), stored, summaries)).flatMap((id) => {
+				const session = byId.get(id);
+				/* v8 ignore next -- ids are projected exclusively from the members used to build byId. */
+				return session === void 0 ? [] : [session];
+			});
 		}
 		/**
-		* Group Sessions by Host Workspace: one group per entity in stable Host
-		* order, with members resolved from sessionIds in their stored order. Sessions
-		* outside every Workspace trail in the browser-local Ungrouped order, which
-		* falls back to recency before that order is initialized.
+		* Group Sessions by Workspace: one group per caller-ordered entity, with
+		* members resolved from caller-ordered sessionIds. Sessions outside every
+		* Workspace trail in the browser-local Ungrouped order, which falls back to
+		* recency before that order is initialized.
 		*/
 		function groupByWorkspace(list, workspaces, archived, ungroupedOrder) {
 			const groups = [];
@@ -398,10 +445,10 @@ window.__ModuleLoader__.load({
 					if (!sessionVisible(summary, list.current, archived)) continue;
 					members.push(summary);
 				}
-				groups.push(buildGroup(workspace.workspaceId, workspace.workspaceId, workspace.path, Date.parse(workspace.createdAt), workspace.title, members, "account"));
+				groups.push(buildGroup(workspace.workspaceId, workspace.workspaceId, workspace.path, Date.parse(workspace.createdAt), workspace.title, members));
 			}
 			const stray = list.ids.map((id) => list.byId[id]).filter((s) => s !== void 0 && !accounted.has(s.id) && sessionVisible(s, list.current, archived));
-			if (stray.length > 0) groups.push(buildGroup("", void 0, void 0, void 0, "", ungroupedOrder === void 0 ? stray : orderedUngrouped(stray, ungroupedOrder), ungroupedOrder === void 0 ? "recency" : "account"));
+			if (stray.length > 0) groups.push(buildGroup("", void 0, void 0, void 0, "", orderedUngrouped(stray, ungroupedOrder, list.byId)));
 			return groups;
 		}
 		/** Keep navigation presentation independent from domain-owned interaction objects. */
@@ -436,7 +483,7 @@ window.__ModuleLoader__.load({
 		* Content search lives outside this derivation
 		* (see {@link deriveSearchResults}).
 		* @param list - sessions list snapshot (`current` feeds containsCurrent).
-		* @param workspaces - real workspaces in stable Host order.
+		* @param workspaces - real Workspaces in Host group order with caller-projected Session order.
 		* @param archivedSessionIds - registry-global archive set.
 		* @param pendingInteractions - pending UI interactions by Session.
 		* @param view - local expansion arrays.
@@ -465,26 +512,28 @@ window.__ModuleLoader__.load({
 			return groups;
 		}
 		/**
-		* Derive the flat session list ("In one list" mode): every session — fork
-		* children included — as a top-level row, strictly newest-first. No grouping,
-		* no parent/child adjacency. Content search lives outside this derivation
-		* (see {@link deriveSearchResults}).
+		* Select flat-list members without deriving row presentation or ordering.
 		* @param list - sessions list snapshot.
 		* @param archivedSessionIds - registry-global archive set.
-		* @param pendingInteractions - pending UI interactions by Session.
-		* @returns flat rows in render order.
+		* @returns known visible Session ids in list order, including ordinary forks and only the current blank.
 		*/
-		function deriveFlat(list, archivedSessionIds, pendingInteractions) {
+		function visibleSessionIds(list, archivedSessionIds) {
 			const archived = new Set(archivedSessionIds);
-			const descendants = indexSubagentDescendants(list.byId);
-			const rows = [];
-			for (const id of list.ids) {
+			return list.ids.filter((id) => {
 				const s = list.byId[id];
-				if (s === void 0 || !sessionVisible(s, list.current, archived)) continue;
-				rows.push(s);
-			}
-			rows.sort(byRecency);
-			return rows.map((session) => sessionNode(session, descendants, pendingInteractions));
+				return s !== void 0 && sessionVisible(s, list.current, archived);
+			});
+		}
+		/**
+		* Derive flat rows from the browser's ordered visible Session ids.
+		* @param list - sessions list snapshot used to select the ids.
+		* @param sessionIds - known visible members in render order, including any pinned blank.
+		* @param pendingInteractions - pending UI interactions by Session.
+		* @returns flat rows in the supplied order with current status indicators.
+		*/
+		function deriveFlat(list, sessionIds, pendingInteractions) {
+			const descendants = indexSubagentDescendants(list.byId);
+			return sessionIds.map((id) => sessionNode(list.byId[id], descendants, pendingInteractions));
 		}
 		/**
 		* Merge immediate title/Workspace substring matches with ranked Host content
@@ -518,7 +567,8 @@ window.__ModuleLoader__.load({
 				if (summary === void 0 || summary.blank || !sessionVisible(summary, list.current, archived)) continue;
 				if (sessionTitle(summary).toLowerCase().includes(q) || labelOf(summary).toLowerCase().includes(q)) local.push(summary);
 			}
-			local.sort(byRecency);
+			const localById = new Map(local.map((summary) => [summary.id, summary]));
+			const orderedLocal = orderByRecency(local.map((summary) => summary.id), list.byId).map((id) => localById.get(id));
 			const ordered = [];
 			const included = /* @__PURE__ */ new Set();
 			const include = (summary) => {
@@ -526,7 +576,7 @@ window.__ModuleLoader__.load({
 				included.add(summary.id);
 				ordered.push(summary);
 			};
-			for (const summary of local) include(summary);
+			for (const summary of orderedLocal) include(summary);
 			for (const item of content.items) {
 				const summary = list.byId[item.sessionId];
 				if (summary !== void 0 && !summary.blank && sessionVisible(summary, list.current, archived)) include(summary);
@@ -927,7 +977,7 @@ window.__ModuleLoader__.load({
 		* @param props.onFork - fork a session at its last completed turn.
 		* @param props.onArchive - archive a session by id.
 		* @param props.onReveal - scroll this row into view after search navigation, then acknowledge it.
-		* @param props.drag - optional draggable-row wiring.
+		* @param props.drag - optional row-drag target wiring; blank rows cannot start a drag.
 		* @param props.flat - omit the empty status slot in the hierarchy-free flat list.
 		* @param props.t - the browser root's locale seat.
 		* @returns the session row.
@@ -938,6 +988,7 @@ window.__ModuleLoader__.load({
 			const selected = node.id === currentId;
 			const statuses = sessionStatuses(node, t);
 			const showStatus = statuses[0].state !== "done" || row.completed;
+			const draggable = drag !== void 0 && !row.blank;
 			const [menuOpen, setMenuOpen] = (0, react.useState)(false);
 			const rowRef = (0, react.useRef)(null);
 			(0, react.useEffect)(() => {
@@ -971,13 +1022,13 @@ window.__ModuleLoader__.load({
 					onClick: () => {
 						onOpen(node.id);
 					},
-					draggable: drag !== void 0,
-					onDragStart: drag === void 0 ? void 0 : (e) => {
+					draggable,
+					onDragStart: drag === void 0 || row.blank ? void 0 : (e) => {
 						e.dataTransfer.effectAllowed = "move";
 						e.dataTransfer.setData("text/plain", node.id);
 						drag.start();
 					},
-					onDragEnd: drag?.end,
+					onDragEnd: drag === void 0 || row.blank ? void 0 : drag.end,
 					onDragOver: drag === void 0 ? void 0 : (e) => {
 						if (!drag.active) return;
 						e.preventDefault();
@@ -1338,58 +1389,6 @@ window.__ModuleLoader__.load({
 				};
 			}, [active]);
 		}
-		/** Reconcile a stored view order with the Workspace's current session account. */
-		function reconciledSessionOrder(sessionIds, stored) {
-			if (stored === void 0) return [...sessionIds];
-			const byId = new Map(sessionIds.map((id) => [id, id]));
-			const ordered = [];
-			const included = /* @__PURE__ */ new Set();
-			for (const key of stored) {
-				const id = byId.get(key);
-				if (id === void 0 || included.has(key)) continue;
-				ordered.push(id);
-				included.add(key);
-			}
-			for (const id of sessionIds) {
-				if (included.has(id)) continue;
-				ordered.push(id);
-			}
-			return ordered;
-		}
-		/** Newest update first with stable Session identity as the tie-break. */
-		function compareSessionRecency(a, b, byId) {
-			const aUpdatedAt = byId[a]?.updatedAt ?? Number.NEGATIVE_INFINITY;
-			const bUpdatedAt = byId[b]?.updatedAt ?? Number.NEGATIVE_INFINITY;
-			if (aUpdatedAt !== bUpdatedAt) return bUpdatedAt - aUpdatedAt;
-			return a < b ? -1 : 1;
-		}
-		/** Reconcile one editable order account and apply its activity-promotion policy. */
-		function nextSessionOrderAccount({ sessionIds, previousOrder, previousUpdatedAt, list, orderBy, sortByRecency }) {
-			let order = reconciledSessionOrder(sessionIds, previousOrder);
-			if (sortByRecency) order.sort((a, b) => compareSessionRecency(a, b, list.byId));
-			else if (orderBy === "updated") {
-				const promoted = sessionIds.filter((id) => {
-					const session = list.byId[id];
-					return session !== void 0 && (previousUpdatedAt[id] === void 0 || session.updatedAt > previousUpdatedAt[id]);
-				}).sort((a, b) => compareSessionRecency(a, b, list.byId));
-				if (promoted.length > 0) {
-					const promotedIds = new Set(promoted);
-					order = [...promoted, ...order.filter((id) => !promotedIds.has(id))];
-				}
-			}
-			const updatedAt = {};
-			for (const id of sessionIds) {
-				const session = list.byId[id];
-				if (session !== void 0) updatedAt[id] = session.updatedAt;
-			}
-			const orderChanged = previousOrder === void 0 || order.length !== previousOrder.length || order.some((id, index) => id !== previousOrder[index]);
-			const timestampsChanged = Object.keys(updatedAt).length !== Object.keys(previousUpdatedAt).length || Object.entries(updatedAt).some(([id, timestamp]) => previousUpdatedAt[id] !== timestamp);
-			return {
-				order,
-				updatedAt,
-				changed: orderChanged || timestampsChanged
-			};
-		}
 		/** Grouping and ordering menu; own open state so it resets with the wide chrome. */
 		function ViewOptionsMenu({ groupBy, orderBy, onGroupPick, onOrderPick, t }) {
 			const [open, setOpen] = (0, react.useState)(false);
@@ -1461,9 +1460,8 @@ window.__ModuleLoader__.load({
 			return e.clientY < rect.top + rect.height / 2 ? "before" : "after";
 		}
 		/** The scrolling session tree; unmounting drops the sessions subscription and expand-all state. */
-		function SessionTree({ useSessions, useSessionPendingInteraction, startSession, open, forkSession, workspaces, archivedSessionIds, workspaceReady, usePanelInfo, onRenameRequest, onDeleteRequest, onSessionRename, onSessionArchive, insertWorkspaceBefore, insertSessionBefore, orderBy, groupExpansion, setGroupExpanded, sessionOrderByAccount, sessionUpdatedAtByAccount, syncSessionOrderAccount, setSessionOrder, home, t, revealSessionId, onSessionRevealed }) {
+		function SessionTree({ list, useSessionPendingInteraction, startSession, open, forkSession, workspaces, ungroupedSessionIds, archivedSessionIds, workspaceReady, usePanelInfo, onRenameRequest, onDeleteRequest, onSessionRename, onSessionArchive, insertWorkspaceBefore, groupExpansion, setGroupExpanded, setSessionOrder, home, t, revealSessionId, onSessionRevealed }) {
 			const panelActive = usePanelInfo((info) => info.activePanelId !== null);
-			const list = useSessions((s) => s);
 			const pendingInteractions = useSessionPendingInteraction((s) => s);
 			const current = panelActive ? void 0 : list.current;
 			const revealGroup = revealSessionId === void 0 || !workspaceReady ? void 0 : owningGroupKey(workspaces, revealSessionId);
@@ -1472,7 +1470,6 @@ window.__ModuleLoader__.load({
 			const sessionDropCommitted = (0, react.useRef)(false);
 			const [workspaceDrag, setWorkspaceDrag] = (0, react.useState)(null);
 			const workspaceDropCommitted = (0, react.useRef)(false);
-			const previousOrderBy = (0, react.useRef)(orderBy);
 			useNativeDragAcceptance(drag !== null || workspaceDrag !== null);
 			const currentGroup = current === void 0 || !workspaceReady ? void 0 : owningGroupKey(workspaces, current);
 			(0, react.useEffect)(() => {
@@ -1485,63 +1482,16 @@ window.__ModuleLoader__.load({
 				groupExpansion
 			]);
 			const expandedGroups = (0, react.useMemo)(() => Object.entries(groupExpansion).filter(([, expanded]) => expanded).map(([key]) => key), [groupExpansion]);
-			const ungroupedSessionIds = (0, react.useMemo)(() => {
-				const accounted = new Set(workspaces.flatMap((workspace) => workspace.sessionIds));
-				return list.ids.filter((id) => list.byId[id] !== void 0 && !accounted.has(id));
-			}, [list, workspaces]);
-			(0, react.useEffect)(() => {
-				if (list.phase !== "ready") return;
-				const switchedToUpdated = previousOrderBy.current !== "updated" && orderBy === "updated";
-				previousOrderBy.current = orderBy;
-				const accounts = [...workspaces.map((workspace) => ({
-					key: workspace.workspaceId,
-					sessionIds: workspace.sessionIds.filter((id) => list.byId[id] !== void 0)
-				})), {
-					key: "",
-					sessionIds: ungroupedSessionIds
-				}];
-				for (const { key, sessionIds } of accounts) {
-					const previousOrder = sessionOrderByAccount[key];
-					const next = nextSessionOrderAccount({
-						sessionIds,
-						previousOrder,
-						previousUpdatedAt: sessionUpdatedAtByAccount[key] ?? {},
-						list,
-						orderBy,
-						sortByRecency: orderBy === "updated" && (previousOrder === void 0 || switchedToUpdated)
-					});
-					if (next.changed) syncSessionOrderAccount(key, next.order.map((id) => id), next.updatedAt);
-				}
-			}, [
-				list,
-				orderBy,
-				sessionOrderByAccount,
-				sessionUpdatedAtByAccount,
-				syncSessionOrderAccount,
-				ungroupedSessionIds,
-				workspaces
-			]);
-			const orderedWorkspaces = (0, react.useMemo)(() => {
-				return workspaces.map((workspace) => {
-					const stored = sessionOrderByAccount[workspace.workspaceId];
-					const sessionIds = reconciledSessionOrder(workspace.sessionIds, stored);
-					return {
-						...workspace,
-						sessionIds
-					};
-				});
-			}, [sessionOrderByAccount, workspaces]);
-			const orderedUngroupedSessionIds = (0, react.useMemo)(() => reconciledSessionOrder(ungroupedSessionIds, sessionOrderByAccount[""]), [sessionOrderByAccount, ungroupedSessionIds]);
-			const groups = (0, react.useMemo)(() => deriveGroups(list, orderedWorkspaces, archivedSessionIds, pendingInteractions, {
+			const groups = (0, react.useMemo)(() => deriveGroups(list, workspaces, archivedSessionIds, pendingInteractions, {
 				expandedGroups,
-				...sessionOrderByAccount[""] === void 0 ? {} : { ungroupedOrder: sessionOrderByAccount[""] }
+				ungroupedOrder: ungroupedSessionIds
 			}), [
 				list,
-				orderedWorkspaces,
+				workspaces,
 				archivedSessionIds,
 				pendingInteractions,
 				expandedGroups,
-				sessionOrderByAccount
+				ungroupedSessionIds
 			]);
 			(0, react.useEffect)(() => {
 				if (revealGroup === void 0 || groupExpansion[revealGroup] === true) return;
@@ -1580,8 +1530,8 @@ window.__ModuleLoader__.load({
 				if (targetWithoutSourceIndex === -1) return;
 				const visibleInsertAt = over.half === "before" ? targetWithoutSourceIndex : targetWithoutSourceIndex + 1;
 				if (sourceIndex !== -1 && visibleInsertAt === sourceIndex) return;
-				const accountSessionIds = activeDrag.accountKey === "" ? orderedUngroupedSessionIds : orderedWorkspaces.find((workspace) => workspace.workspaceId === activeDrag.accountKey)?.sessionIds;
-				if (accountSessionIds === void 0) return;
+				const accountSessionIds = activeDrag.accountKey === "" ? ungroupedSessionIds : workspaces.find((workspace) => workspace.workspaceId === activeDrag.accountKey)?.sessionIds;
+				if (accountSessionIds === void 0 || !accountSessionIds.includes(activeDrag.sessionId)) return;
 				const nextOrder = accountSessionIds.filter((id) => id !== activeDrag.sessionId);
 				let anchor;
 				if (sessionsExpanded) anchor = over.half === "before" ? over.id : renderedSessions[targetIndex + 1]?.id;
@@ -1603,11 +1553,8 @@ window.__ModuleLoader__.load({
 						return node === void 0 ? [] : [node];
 					})).rows.some((node) => node.id === activeDrag.sessionId)) return;
 				}
-				setSessionOrder(activeDrag.accountKey, nextOrder.map((id) => id));
-				if (orderBy === "updated" || activeDrag.accountKey === "") return;
-				insertSessionBefore(activeDrag.accountKey, activeDrag.sessionId, anchor).catch((reason) => {
-					console.warn("session reorder rejected:", reason);
-				});
+				const currentBlank = group.sessions.find((node) => node.blank)?.id;
+				setSessionOrder(activeDrag.accountKey, pinCurrentBlank(nextOrder, currentBlank));
 			};
 			const commitWorkspaceDrag = (activeDrag, over) => {
 				if (workspaceDropCommitted.current) return;
@@ -1714,6 +1661,7 @@ window.__ModuleLoader__.load({
 									}),
 									(sessionsExpanded ? group.sessions : collapsed.rows).map((node) => {
 										const sameGroupDrag = drag !== null && drag.accountKey === group.key;
+										const normalizeHalf = (half) => node.blank ? "after" : half;
 										const dragProps = {
 											start: () => {
 												sessionDropCommitted.current = false;
@@ -1731,7 +1679,7 @@ window.__ModuleLoader__.load({
 													...d,
 													over: {
 														id: node.id,
-														half
+														half: normalizeHalf(half)
 													}
 												});
 											},
@@ -1740,7 +1688,7 @@ window.__ModuleLoader__.load({
 												if (drag === null) return;
 												commitSessionDrag(drag, {
 													id: node.id,
-													half
+													half: normalizeHalf(half)
 												});
 											},
 											end: () => {
@@ -1782,50 +1730,13 @@ window.__ModuleLoader__.load({
 			});
 		}
 		/** The flat "In one list" body: every session is one draggable top-level row. */
-		function FlatList({ useSessions, useSessionPendingInteraction, open, forkSession, onSessionRename, onSessionArchive, archivedSessionIds, usePanelInfo, orderBy, sessionOrderByAccount, sessionUpdatedAtByAccount, syncSessionOrderAccount, setSessionOrder, revealSessionId, onSessionRevealed, t }) {
+		function FlatList({ list, sessionIds, useSessionPendingInteraction, open, forkSession, onSessionRename, onSessionArchive, usePanelInfo, setSessionOrder, revealSessionId, onSessionRevealed, t }) {
 			const panelActive = usePanelInfo((info) => info.activePanelId !== null);
-			const list = useSessions((s) => s);
 			const pendingInteractions = useSessionPendingInteraction((s) => s);
-			const baseRows = (0, react.useMemo)(() => deriveFlat(list, archivedSessionIds, pendingInteractions), [
+			const rows = (0, react.useMemo)(() => deriveFlat(list, sessionIds, pendingInteractions), [
 				list,
-				archivedSessionIds,
-				pendingInteractions
-			]);
-			const sessionIds = (0, react.useMemo)(() => baseRows.map((row) => row.id), [baseRows]);
-			const previousOrderBy = (0, react.useRef)(orderBy);
-			(0, react.useEffect)(() => {
-				if (list.phase !== "ready") return;
-				const previousOrder = sessionOrderByAccount[FLAT_SESSION_ORDER_KEY];
-				const previousUpdatedAt = sessionUpdatedAtByAccount["__flat_session_order__"] ?? {};
-				const switchedToUpdated = previousOrderBy.current !== "updated" && orderBy === "updated";
-				previousOrderBy.current = orderBy;
-				const next = nextSessionOrderAccount({
-					sessionIds,
-					previousOrder,
-					previousUpdatedAt,
-					list,
-					orderBy,
-					sortByRecency: orderBy === "updated" && (previousOrder === void 0 || switchedToUpdated)
-				});
-				if (next.changed) syncSessionOrderAccount(FLAT_SESSION_ORDER_KEY, next.order.map((id) => id), next.updatedAt);
-			}, [
-				list,
-				orderBy,
-				sessionOrderByAccount,
-				sessionUpdatedAtByAccount,
 				sessionIds,
-				syncSessionOrderAccount
-			]);
-			const rows = (0, react.useMemo)(() => {
-				const byId = new Map(baseRows.map((row) => [row.id, row]));
-				return reconciledSessionOrder(sessionIds, sessionOrderByAccount[FLAT_SESSION_ORDER_KEY]).flatMap((id) => {
-					const row = byId.get(id);
-					return row === void 0 ? [] : [row];
-				});
-			}, [
-				baseRows,
-				sessionOrderByAccount,
-				sessionIds
+				pendingInteractions
 			]);
 			const [drag, setDrag] = (0, react.useState)(null);
 			const dropCommitted = (0, react.useRef)(false);
@@ -1844,7 +1755,8 @@ window.__ModuleLoader__.load({
 				const nextOrder = rows.map((row) => row.id).filter((id) => id !== activeDrag.sessionId);
 				const insertAt = anchor === void 0 ? nextOrder.length : nextOrder.indexOf(anchor);
 				nextOrder.splice(insertAt === -1 ? nextOrder.length : insertAt, 0, activeDrag.sessionId);
-				setSessionOrder(FLAT_SESSION_ORDER_KEY, nextOrder.map((id) => id));
+				const currentBlank = rows.find((node) => node.blank)?.id;
+				setSessionOrder(FLAT_SESSION_ORDER_KEY, pinCurrentBlank(nextOrder, currentBlank));
 			};
 			const now = Date.now();
 			return (0, react_jsx_runtime.jsxs)("div", {
@@ -1858,6 +1770,7 @@ window.__ModuleLoader__.load({
 						children: t("empty.none")
 					}), rows.map((node) => {
 						const active = drag !== null;
+						const normalizeHalf = (half) => node.blank ? "after" : half;
 						return (0, react_jsx_runtime.jsx)(SessionNodeItem, {
 							node,
 							currentId: panelActive ? void 0 : list.current,
@@ -1886,14 +1799,14 @@ window.__ModuleLoader__.load({
 										...current,
 										over: {
 											id: node.id,
-											half
+											half: normalizeHalf(half)
 										}
 									});
 								},
 								drop: (half) => {
 									if (drag !== null) commitDrag(drag, {
 										id: node.id,
-										half
+										half: normalizeHalf(half)
 									});
 								},
 								end: () => {
@@ -1973,8 +1886,9 @@ window.__ModuleLoader__.load({
 		* @param props - composed slot props (shell owner share + store + injected actions).
 		* @returns the region element tree.
 		*/
-		function WorkspaceBrowser({ wide, usePanelInfo, expandSidebar, useSessions, useSessionPendingInteraction, useWorkspaces, useStore, actions, startSession, open, renameSession, forkSession, renameWorkspace, deleteWorkspace, insertWorkspaceBefore, archiveSession, insertSessionBefore, createWorkspace, searchSessions, searchResultLimit, useDirectoryFlow, useHostInfo, renderSlot, t }) {
+		function WorkspaceBrowser({ wide, usePanelInfo, expandSidebar, useSessions, useSessionPendingInteraction, useWorkspaces, useStore, actions, startSession, open, renameSession, forkSession, renameWorkspace, deleteWorkspace, insertWorkspaceBefore, archiveSession, createWorkspace, searchSessions, searchResultLimit, useDirectoryFlow, useHostInfo, renderSlot, t }) {
 			const home = useHostInfo((info) => info.home);
+			const list = useSessions((state) => state);
 			const workspaces = useWorkspaces((state) => state.items);
 			const workspacePhase = useWorkspaces((state) => state.phase);
 			const workspaceStreamState = useWorkspaces((state) => state.state);
@@ -1984,34 +1898,54 @@ window.__ModuleLoader__.load({
 			const orderBy = useStore((s) => s.orderBy);
 			const groupExpansion = useStore((s) => s.groupExpansion);
 			const sessionOrderByAccount = useStore((s) => s.sessionOrderByAccount);
-			const sessionUpdatedAtByAccount = useStore((s) => s.sessionUpdatedAtByAccount);
-			const currentBlankSessionId = useSessions((state) => {
-				const current = state.current;
-				return current !== void 0 && state.byId[current]?.blank === true ? current : void 0;
-			});
-			const currentBlankAccount = currentBlankSessionId === void 0 || workspacePhase !== "ready" ? void 0 : owningGroupKey(workspaces, currentBlankSessionId);
-			const promotedBlank = (0, react.useRef)(void 0);
-			(0, react.useEffect)(() => {
-				if (currentBlankSessionId === void 0 || currentBlankAccount === void 0) {
-					promotedBlank.current = void 0;
-					return;
-				}
-				const promoted = promotedBlank.current;
-				if (promoted !== void 0 && promoted.sessionId === currentBlankSessionId && promoted.accountKey === currentBlankAccount) return;
-				promotedBlank.current = {
-					sessionId: currentBlankSessionId,
-					accountKey: currentBlankAccount
+			const workspaceReady = workspacePhase === "ready" && workspaceStreamState !== "loading";
+			const currentBlank = list.current !== void 0 && list.byId[list.current]?.blank === true ? list.current : void 0;
+			const ungroupedMemberIds = (0, react.useMemo)(() => {
+				const accounted = new Set(workspaces.flatMap((workspace) => workspace.sessionIds));
+				return list.ids.filter((id) => list.byId[id] !== void 0 && !accounted.has(id));
+			}, [list, workspaces]);
+			const flatMemberIds = (0, react.useMemo)(() => visibleSessionIds(list, archivedSessionIds), [archivedSessionIds, list]);
+			const orderedWorkspaces = (0, react.useMemo)(() => workspaces.map((workspace) => {
+				const memberIds = workspace.sessionIds;
+				const baseOrder = orderBy === "updated" ? orderByRecency(memberIds, list.byId) : reconcileManualOrder(memberIds, sessionOrderByAccount[workspace.workspaceId], list.byId);
+				return {
+					...workspace,
+					sessionIds: pinCurrentBlank(baseOrder, currentBlank !== void 0 && memberIds.includes(currentBlank) ? currentBlank : void 0)
 				};
-				for (const accountKey of new Set([currentBlankAccount, FLAT_SESSION_ORDER_KEY])) {
-					const previous = sessionOrderByAccount[accountKey] ?? [];
-					actions.setSessionOrder(accountKey, [currentBlankSessionId, ...previous.filter((id) => id !== currentBlankSessionId)]);
-				}
+			}), [
+				currentBlank,
+				list.byId,
+				orderBy,
+				sessionOrderByAccount,
+				workspaces
+			]);
+			const orderedUngroupedSessionIds = (0, react.useMemo)(() => {
+				return pinCurrentBlank(orderBy === "updated" ? orderByRecency(ungroupedMemberIds, list.byId) : reconcileManualOrder(ungroupedMemberIds, sessionOrderByAccount[""], list.byId), currentBlank !== void 0 && ungroupedMemberIds.includes(currentBlank) ? currentBlank : void 0);
 			}, [
-				actions.setSessionOrder,
-				currentBlankAccount,
-				currentBlankSessionId,
+				currentBlank,
+				list.byId,
+				orderBy,
+				sessionOrderByAccount,
+				ungroupedMemberIds
+			]);
+			const orderedFlatSessionIds = (0, react.useMemo)(() => {
+				return pinCurrentBlank(orderBy === "updated" ? orderByRecency(flatMemberIds, list.byId) : reconcileManualOrder(flatMemberIds, sessionOrderByAccount[FLAT_SESSION_ORDER_KEY], list.byId), currentBlank !== void 0 && flatMemberIds.includes(currentBlank) ? currentBlank : void 0);
+			}, [
+				currentBlank,
+				flatMemberIds,
+				list.byId,
+				orderBy,
 				sessionOrderByAccount
 			]);
+			const activeSessionOrders = (0, react.useMemo)(() => Object.fromEntries([
+				...orderedWorkspaces.map((workspace) => [workspace.workspaceId, workspace.sessionIds]),
+				["", orderedUngroupedSessionIds],
+				[FLAT_SESSION_ORDER_KEY, orderedFlatSessionIds]
+			]), [
+				orderedFlatSessionIds,
+				orderedUngroupedSessionIds,
+				orderedWorkspaces
+			]);
 			(0, react.useEffect)(() => {
 				if (workspacePhase !== "ready") return;
 				actions.retainAccountKeys([
@@ -2024,6 +1958,44 @@ window.__ModuleLoader__.load({
 				workspacePhase,
 				workspaces
 			]);
+			(0, react.useEffect)(() => {
+				if (list.phase !== "ready" || workspaceReady || orderBy !== "manual" || currentBlank === void 0) return;
+				const changed = {};
+				for (const [key, ids] of Object.entries(activeSessionOrders)) {
+					if (key !== "__flat_session_order__" && workspacePhase !== "ready") continue;
+					const saved = sessionOrderByAccount[key] ?? [];
+					if (ids[0] !== currentBlank || saved[0] === currentBlank) continue;
+					changed[key] = [currentBlank, ...saved.filter((id) => id !== currentBlank)];
+				}
+				if (Object.keys(changed).length > 0) actions.syncSessionOrders(changed);
+			}, [
+				actions.syncSessionOrders,
+				activeSessionOrders,
+				currentBlank,
+				list.phase,
+				orderBy,
+				sessionOrderByAccount,
+				workspacePhase,
+				workspaceReady
+			]);
+			(0, react.useEffect)(() => {
+				if (list.phase !== "ready" || !workspaceReady || orderBy !== "manual") return;
+				const changed = Object.fromEntries(Object.entries(activeSessionOrders).filter(([key, ids]) => {
+					const saved = sessionOrderByAccount[key];
+					return saved === void 0 || saved.length !== ids.length || ids.some((id, index) => id !== saved[index]);
+				}));
+				if (Object.keys(changed).length > 0) actions.syncSessionOrders(changed);
+			}, [
+				actions.syncSessionOrders,
+				activeSessionOrders,
+				list.phase,
+				orderBy,
+				sessionOrderByAccount,
+				workspaceReady
+			]);
+			const saveSessionOrder = (accountKey, order) => {
+				actions.setSessionOrder(accountKey, order, activeSessionOrders);
+			};
 			const [query, setQuery] = (0, react.useState)("");
 			const [searchExpanded, setSearchExpanded] = (0, react.useState)(false);
 			const [revealSessionId, setRevealSessionId] = (0, react.useState)(void 0);
@@ -2296,7 +2268,7 @@ window.__ModuleLoader__.load({
 										actions.setGroupBy(mode);
 									},
 									onOrderPick: (mode) => {
-										actions.setOrderBy(mode);
+										actions.setOrderBy(mode, activeSessionOrders);
 									},
 									t
 								}), directoryFlowAvailable && (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Tooltip, {
@@ -2367,42 +2339,34 @@ window.__ModuleLoader__.load({
 							t
 						}) : groupBy === "flat" ? (0, react_jsx_runtime.jsx)(FlatList, {
 							usePanelInfo,
-							useSessions,
+							list,
+							sessionIds: orderedFlatSessionIds,
 							useSessionPendingInteraction,
 							open,
 							forkSession,
 							onSessionRename,
 							onSessionArchive,
-							archivedSessionIds,
-							orderBy,
-							sessionOrderByAccount,
-							sessionUpdatedAtByAccount,
-							syncSessionOrderAccount: actions.syncSessionOrderAccount,
-							setSessionOrder: actions.setSessionOrder,
+							setSessionOrder: saveSessionOrder,
 							revealSessionId,
 							onSessionRevealed: acknowledgeSessionReveal,
 							t
 						}) : (0, react_jsx_runtime.jsx)(SessionTree, {
 							usePanelInfo,
-							useSessions,
+							list,
 							useSessionPendingInteraction,
 							onSessionRename,
 							onSessionArchive,
 							forkSession,
-							workspaces,
-							workspaceReady: workspacePhase === "ready" && workspaceStreamState !== "loading",
+							workspaces: orderedWorkspaces,
+							ungroupedSessionIds: orderedUngroupedSessionIds,
+							workspaceReady,
 							groupExpansion,
 							setGroupExpanded: actions.setGroupExpanded,
-							sessionOrderByAccount,
-							sessionUpdatedAtByAccount,
-							syncSessionOrderAccount: actions.syncSessionOrderAccount,
-							setSessionOrder: actions.setSessionOrder,
+							setSessionOrder: saveSessionOrder,
 							archivedSessionIds,
 							startSession,
 							open,
 							insertWorkspaceBefore,
-							insertSessionBefore,
-							orderBy,
 							revealSessionId,
 							onSessionRevealed: acknowledgeSessionReveal,
 							home,
@@ -2778,9 +2742,6 @@ window.__ModuleLoader__.load({
 				archiveSession: async (sessionId) => {
 					await uiWorkspace.archiveSession(sessionId);
 				},
-				insertSessionBefore: async (workspaceId, sessionId, beforeSessionId) => {
-					await workspaces.insertSessionBefore(workspaceId, sessionId, beforeSessionId);
-				},
 				createWorkspace: (input) => workspaces.create(input),
 				hooks: {
 					directoryFlow: browserFlowSource,

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

@@ -130,12 +130,6 @@ export type WorkspaceBrowserInjected = {
      * session clears the selection into the New Session view state.
      */
     archiveSession: (sessionId: SessionId) => Promise<void>;
-    /**
-     * Reorder a session inside its Workspace account (DOM-insertBefore
-     * semantics: omitted anchor appends to the end). The view refreshes from
-     * the Host response/changed frame; failures leave the order unchanged.
-     */
-    insertSessionBefore: (workspaceId: WorkspaceId, sessionId: SessionId, beforeSessionId?: SessionId) => Promise<void>;
     /** Adopt a picked host directory as a real Workspace before targeting a Session. */
     createWorkspace: (input: {
         path: string;

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

@@ -40,6 +40,11 @@ export interface UiWorkspace {
      * @param sessionId - Session to archive.
      */
     archiveSession(sessionId: SessionId): Promise<void>;
+    /**
+     * Unarchive a Session, restoring it to its recorded Workspace position.
+     * @param sessionId - Session to unarchive.
+     */
+    unarchiveSession(sessionId: SessionId): Promise<void>;
     /**
      * Open the Host-native directory picker.
      * @returns the selected directory, or null when cancelled.
@@ -93,6 +98,7 @@ declare class UiWorkspaceService extends Service implements UiWorkspace {
     forkSession(sessionId: SessionId): Promise<void>;
     startSession(workspaceId?: WorkspaceId): void;
     archiveSession(sessionId: SessionId): Promise<void>;
+    unarchiveSession(sessionId: SessionId): Promise<void>;
     pickDirectory(): Promise<string | null>;
     listDirectory(path?: string, signal?: AbortSignal): Promise<DirectoryListing>;
     createDirectory(path: string, name: string): Promise<string>;

package/lib/types/client/rows/Rows.d.ts

@@ -78,7 +78,7 @@ export declare function SearchResultItem({ result, currentId, onOpen, t }: {
  * @param props.onFork - fork a session at its last completed turn.
  * @param props.onArchive - archive a session by id.
  * @param props.onReveal - scroll this row into view after search navigation, then acknowledge it.
- * @param props.drag - optional draggable-row wiring.
+ * @param props.drag - optional row-drag target wiring; blank rows cannot start a drag.
  * @param props.flat - omit the empty status slot in the hierarchy-free flat list.
  * @param props.t - the browser root's locale seat.
  * @returns the session row.
@@ -96,7 +96,7 @@ export declare function SessionNodeItem({ node, currentId, now, onOpen, onRename
     onArchive: (id: SessionNode['id']) => void;
     /** Scroll this row into view after search navigation, then acknowledge it. */
     onReveal?: (() => void) | undefined;
-    /** Present only on draggable rows (workspace-group sessions outside search). */
+    /** Present on reorderable-list rows so every row can remain a drop target. */
     drag?: RowDragProps | undefined;
     /** The row is rendered without a parent Workspace header. */
     flat?: boolean | undefined;

package/lib/types/client/rows/WorkspaceBrowser.d.ts

@@ -4,5 +4,5 @@ import type { WorkspaceBrowserProps } from '../contract/slots.ts';
  * @param props - composed slot props (shell owner share + store + injected actions).
  * @returns the region element tree.
  */
-export declare function WorkspaceBrowser({ wide, usePanelInfo, expandSidebar, useSessions, useSessionPendingInteraction, useWorkspaces, useStore, actions, startSession, open, renameSession, forkSession, renameWorkspace, deleteWorkspace, insertWorkspaceBefore, archiveSession, insertSessionBefore, createWorkspace, searchSessions, searchResultLimit, useDirectoryFlow, useHostInfo, renderSlot, t, }: WorkspaceBrowserProps): import("react").JSX.Element;
+export declare function WorkspaceBrowser({ wide, usePanelInfo, expandSidebar, useSessions, useSessionPendingInteraction, useWorkspaces, useStore, actions, startSession, open, renameSession, forkSession, renameWorkspace, deleteWorkspace, insertWorkspaceBefore, archiveSession, createWorkspace, searchSessions, searchResultLimit, useDirectoryFlow, useHostInfo, renderSlot, t, }: WorkspaceBrowserProps): import("react").JSX.Element;
 //# sourceMappingURL=WorkspaceBrowser.d.ts.map

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

@@ -10,7 +10,7 @@ import { type EngineStoreHandle } from '@deepseek-ai/dsh-client-store';
 export declare const FLAT_SESSION_ORDER_KEY = "__flat_session_order__";
 /** Session-list grouping mode: workspace sections or one flat recency list. */
 export type SessionGroupBy = 'workspace' | 'flat';
-/** Session order: user-arranged only, or user-arranged plus activity promotion. */
+/** Session order: saved manual positions or current recency. */
 export type SessionOrderBy = 'manual' | 'updated';
 /** Workspace browser viewing state persisted across surface remounts and reloads. */
 type WorkspaceViewState = {
@@ -18,10 +18,8 @@ type WorkspaceViewState = {
     orderBy: SessionOrderBy;
     /** Explicit zero-or-five-session state keyed by Workspace group identity. */
     groupExpansion: Record<string, boolean>;
-    /** Shared editable order per Workspace group plus the browser-local flat-list account. */
+    /** Saved manual order per Workspace group plus the browser-local flat-list account. */
     sessionOrderByAccount: Record<string, string[]>;
-    /** Last observed update timestamps per order account for one-time promotion events. */
-    sessionUpdatedAtByAccount: Record<string, Record<string, number>>;
 };
 /**
  * Annotation twin of the actions literal below (the export needs a declared
@@ -29,11 +27,11 @@ type WorkspaceViewState = {
  */
 type WorkspaceViewActions = {
     setGroupBy: (draft: WorkspaceViewState, mode: SessionGroupBy) => void;
-    setOrderBy: (draft: WorkspaceViewState, mode: SessionOrderBy) => void;
+    setOrderBy: (draft: WorkspaceViewState, mode: SessionOrderBy, initialOrders: Readonly<Record<string, readonly string[]>>) => void;
     setGroupExpanded: (draft: WorkspaceViewState, key: string, expanded: boolean) => void;
     retainAccountKeys: (draft: WorkspaceViewState, workspaceKeys: readonly string[]) => void;
-    syncSessionOrderAccount: (draft: WorkspaceViewState, accountKey: string, order: string[], updatedAt: Record<string, number>) => void;
-    setSessionOrder: (draft: WorkspaceViewState, accountKey: string, order: string[]) => void;
+    syncSessionOrders: (draft: WorkspaceViewState, orders: Readonly<Record<string, readonly string[]>>) => void;
+    setSessionOrder: (draft: WorkspaceViewState, accountKey: string, order: readonly string[], initialOrders: Readonly<Record<string, readonly string[]>>) => void;
 };
 /**
  * Create the workspace browser viewing store handle.

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

@@ -1,7 +1,7 @@
 /**
- * Derives the workspace browser tree from Host Workspace order and membership.
- * Unassigned Sessions trail under Ungrouped; only the selected blank Session
- * remains visible.
+ * Derives the workspace browser tree from caller-projected Workspace and
+ * Session order. Unassigned Sessions trail under Ungrouped; only the selected
+ * blank Session remains visible.
  */
 import { type SessionListState, type SessionSearchResultItem } from '@deepseek-ai/dsh-api-session-controller/client';
 import type { WorkspaceId, WorkspaceView } from '@deepseek-ai/dsh-api-workspace-controller/client';
@@ -91,6 +91,28 @@ export interface TreeView {
  * @returns basename, the raw cwd when it has no basename, or an empty ungrouped marker.
  */
 export declare function workspaceLabel(cwd: string | undefined): string;
+/**
+ * Project known account members by current Session recency.
+ * @param sessionIds - authoritative account membership.
+ * @param summaries - current Session summaries; members without a summary are omitted until it arrives.
+ * @returns known members newest first, with Session identity as the deterministic tie-break.
+ */
+export declare function orderByRecency(sessionIds: readonly SessionId[], summaries: SessionListState['byId']): SessionId[];
+/**
+ * Reconcile a browser-local manual order with current account membership.
+ * @param memberIds - authoritative account membership.
+ * @param savedOrder - previously saved browser-local order.
+ * @param summaries - current Session summaries used to append newly known members by recency.
+ * @returns retained saved slots followed by newly known members; departed members and unknown new members are omitted.
+ */
+export declare function reconcileManualOrder(memberIds: readonly SessionId[], savedOrder: readonly string[] | undefined, summaries: SessionListState['byId']): SessionId[];
+/**
+ * Keep the selected provisional New Session ahead of either base order.
+ * @param order - recency or reconciled manual order.
+ * @param currentBlank - selected blank Session in this account, when present.
+ * @returns a copy with the selected blank first and no duplicate slot.
+ */
+export declare function pinCurrentBlank(order: readonly SessionId[], currentBlank: SessionId | undefined): SessionId[];
 /**
  * Derive the workspace browser groups with every session as a top-level row.
  *
@@ -100,7 +122,7 @@ export declare function workspaceLabel(cwd: string | undefined): string;
  * Content search lives outside this derivation
  * (see {@link deriveSearchResults}).
  * @param list - sessions list snapshot (`current` feeds containsCurrent).
- * @param workspaces - real workspaces in stable Host order.
+ * @param workspaces - real Workspaces in Host group order with caller-projected Session order.
  * @param archivedSessionIds - registry-global archive set.
  * @param pendingInteractions - pending UI interactions by Session.
  * @param view - local expansion arrays.
@@ -108,16 +130,20 @@ export declare function workspaceLabel(cwd: string | undefined): string;
  */
 export declare function deriveGroups(list: SessionListState, workspaces: readonly WorkspaceView[], archivedSessionIds: readonly SessionId[], pendingInteractions: SessionPendingInteractions, view: TreeView): GroupNode[];
 /**
- * Derive the flat session list ("In one list" mode): every session — fork
- * children included — as a top-level row, strictly newest-first. No grouping,
- * no parent/child adjacency. Content search lives outside this derivation
- * (see {@link deriveSearchResults}).
+ * Select flat-list members without deriving row presentation or ordering.
  * @param list - sessions list snapshot.
  * @param archivedSessionIds - registry-global archive set.
+ * @returns known visible Session ids in list order, including ordinary forks and only the current blank.
+ */
+export declare function visibleSessionIds(list: SessionListState, archivedSessionIds: readonly SessionId[]): SessionId[];
+/**
+ * Derive flat rows from the browser's ordered visible Session ids.
+ * @param list - sessions list snapshot used to select the ids.
+ * @param sessionIds - known visible members in render order, including any pinned blank.
  * @param pendingInteractions - pending UI interactions by Session.
- * @returns flat rows in render order.
+ * @returns flat rows in the supplied order with current status indicators.
  */
-export declare function deriveFlat(list: SessionListState, archivedSessionIds: readonly SessionId[], pendingInteractions: SessionPendingInteractions): SessionNode[];
+export declare function deriveFlat(list: SessionListState, sessionIds: readonly SessionId[], pendingInteractions: SessionPendingInteractions): SessionNode[];
 /**
  * Merge immediate title/Workspace substring matches with ranked Host content
  * matches. Local rows lead newest-first, content-only rows retain backend

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-client-ui-workspace",
   "description": "Workspace picker plugin: one WorkspacePicker registered into the sidebar and empty-state workspace slots",
-  "version": "0.1.5-rc.2",
+  "version": "0.1.6-alpha.1",
   "publishConfig": {
     "access": "public"
   },
@@ -50,25 +50,25 @@
     "@types/react": "~18.3.1",
     "react": "^18.2.0",
     "clsx": "^2.0.0",
-    "@deepseek-ai/dsh-api-remotes": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-api-session-controller": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-api-workspace-controller": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-locale": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-store": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-connection": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-layout": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-sidebar": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-session": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-schedule": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-typert-protocol": "^0.1.5-rc.2",
-    "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-util-workspace-path": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-session": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-test-runtime": "^0.1.5-rc.2"
+    "@deepseek-ai/dsh-api-remotes": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-api-session-controller": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-api-workspace-controller": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-connection": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-locale": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-store": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-test-runtime": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-ui-layout": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-ui-session": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-ui-sidebar": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-session": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-util-workspace-path": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-schedule": "^0.1.6-alpha.1",
+    "@deepseek-ai/cordis": "^4.0.2"
   },
   "files": [
     "lib/index.js",