@veewo/dsh-better-tasks 0.4.4 → 0.4.5

package/README.md

@@ -4,15 +4,15 @@ DSH 侧栏任务泳道：共享原生 Pin、独立任务输入、Final 预览与
 
 ## 按 DSH 版本安装
 
-**当前 rc.3 分发组合：DSH Desktop `0.2.2-rc.3` + Better Tasks `0.4.4`（Pre-release）。**
+**当前 rc.3 分发组合：DSH Desktop `0.2.2-rc.3` + Better Tasks `0.4.5`（Pre-release）。**
 
-修复子/孙 agent 仍运行时任务卡误显示 idle；选中会话标题使用 DSH 主题蓝色。安装必须取齐[rc.3 完整七包](<https://github.com/chanyuenpang/dsh-better-tasks/releases/tag/dsh-v0.2.2-rc.3-tasks-v0.4.4>)，按[rc.3 安装说明](<docs/install-rc3.md>)处理；npm 主包不是完整运行时组合。以下 rc.2 入口保留供仍在使用 rc.2 的用户。
+已合并初始化优化：不扫描会话历史、按持久化的完整顺序恢复任务，并区分顺序恢复与旧队列导入提示；同时保留子/孙 agent 活跃状态修复和选中标题主题蓝色。安装必须取齐[rc.3 完整七包](<https://github.com/chanyuenpang/dsh-better-tasks/releases/tag/dsh-v0.2.2-rc.3-tasks-v0.4.5>)，按[rc.3 安装说明](<docs/install-rc3.md>)处理；npm 主包不是完整运行时组合。以下 rc.2 入口保留供仍在使用 rc.2 的用户。
 
 0.4.1 包含新任务排序与斜杠提交修复，必须同步更新主包和本 Release 的 conversation fork，见[安装说明](<docs/install.md>)。旧 [0.4.0 组合](<https://github.com/chanyuenpang/dsh-better-tasks/releases/tag/dsh-v0.2.2-rc.2-tasks-v0.4.0>)保留供回滚。
 
 | DSH Desktop 运行时 | Better Tasks | 完整安装入口 |
 |---|---|---|
-| `0.2.2-rc.3` | `0.4.4` | [dsh-v0.2.2-rc.3-tasks-v0.4.4](<https://github.com/chanyuenpang/dsh-better-tasks/releases/tag/dsh-v0.2.2-rc.3-tasks-v0.4.4>)（会话活跃态与选中标题修复） |
+| `0.2.2-rc.3` | `0.4.5` | [dsh-v0.2.2-rc.3-tasks-v0.4.5](<https://github.com/chanyuenpang/dsh-better-tasks/releases/tag/dsh-v0.2.2-rc.3-tasks-v0.4.5>)（会话活跃态与选中标题修复） |
 | `0.2.2-rc.2` | `0.4.1` | [dsh-v0.2.2-rc.2-tasks-v0.4.1](<https://github.com/chanyuenpang/dsh-better-tasks/releases/tag/dsh-v0.2.2-rc.2-tasks-v0.4.1>)（含输入框回退修复） |
 | `0.2.1-rc.2` | `0.3.2` | [历史插件](<https://github.com/chanyuenpang/dsh-better-tasks/releases/tag/v0.3.2>) + [对应 fork 库](<https://github.com/chanyuenpang/dsh-better-tasks/releases/tag/better-tasks-forks-0.2.1-rc.2-r1>) |
 | `0.2.0-rc.2` | `0.3.1` | [历史发行版](<https://github.com/chanyuenpang/dsh-better-tasks/releases/tag/v0.3.1>) |
@@ -21,8 +21,8 @@ DSH 侧栏任务泳道：共享原生 Pin、独立任务输入、Final 预览与
 
 **完整安装 = 插件本体 + 同一 Release 的六个 UI fork，共 7 个 `.tgz`。** 源码 ZIP 和单独 npm 包都不是完整安装包。六个 fork 保留原生包名，属于本项目兼容性修改，并非 DeepSeek 官方发行包。
 
-1. 从[当前 Release](<https://github.com/chanyuenpang/dsh-better-tasks/releases/tag/dsh-v0.2.2-rc.2-tasks-v0.4.1>)取齐七包、`release-manifest.json`、`SHA256SUMS.txt` 和 `INSTALL.md`。
-2. 按[安装说明](<docs/install.md>)校验并备份自己的 Profile，配置 `nodeLinker: isolated` 与六个精确的 `publicHoistPattern`。
+1. 按表格中的完整 DSH 版本选择 Release，取齐七包、`release-manifest.json`、`SHA256SUMS.txt` 和 `INSTALL.md`；rc.3 使用 0.4.5，rc.2 保留 0.4.1。
+2. 按对应的 [rc.3 安装说明](<docs/install-rc3.md>)或 [rc.2 安装说明](<docs/install.md>)校验并备份自己的 Profile，配置 `nodeLinker: isolated` 与六个精确的 `publicHoistPattern`。
 3. 完全退出 Desktop（含托盘），安装七包，再手动启动验收。升级与卸载见[回滚说明](<docs/rollback.md>)。
 
 本次完整 Release 包含最新 `ui-user-questions` 修复。较早的 `better-tasks-forks-0.2.2-rc.2` 是历史 fork 库，不含这次最终修复，不要与本次七包混用。
@@ -47,7 +47,7 @@ Source patches live under [src-patches](<src-patches/>), project-owned modules u
 
 **仅在 `main` 上开发和提交**；不再维护按功能、发布或 DSH 版本划分的长期分支。已有分支仅保留历史引用。支持版本只由 `main` 上不可变的 `dsh-v<DSH版本>-tasks-v<Tasks版本>` annotated tag 与完整 Release 标记，`main` 的最新提交不等于已经发布或适配完成，详见[发布规范](<docs/release.md>)。
 
-rc.3 的 HOC 与六个 fork 来源见[0.4.2 适配记录](<docs/dsh-0.2.2-rc.3-support.md>)；0.4.4 在其基础上加入[会话活跃状态与选中标题修复](<docs/task-session-activity.md>)。精确七包哈希及启动结果随 Release 的 `validation.json` 交付。rc.2 入口保持不变，不混装旧 rc.3 产物或仅按 npm latest 安装。
+rc.3 的 HOC 与六个 fork 来源见[0.4.2 适配记录](<docs/dsh-0.2.2-rc.3-support.md>)；0.4.5 合并[初始化与完整顺序持久化](<docs/task-order-persistence.md>)，并保留 0.4.4 的[会话活跃状态与选中标题修复](<docs/task-session-activity.md>)。精确七包哈希及启动结果随 Release 的 `validation.json` 交付。rc.2 入口保持不变，不混装旧 rc.3 产物或仅按 npm latest 安装。
 
 侧栏新增按钮、调整排版或适配新 DSH 前，先遵循[侧栏排版与适配规范](<docs/sidebar-layout.md>)；数字、原生语义样式与版本合同分层维护。
 

package/docs/install-rc3.md

@@ -1,6 +1,6 @@
-# 安装：DSH 0.2.2-rc.3 / Tasks 0.4.4
+# 安装：DSH 0.2.2-rc.3 / Tasks 0.4.5
 
-组合标识：`dsh-v0.2.2-rc.3-tasks-v0.4.4`。完整七包见[固定版本 Release](<https://github.com/chanyuenpang/dsh-better-tasks/releases/tag/dsh-v0.2.2-rc.3-tasks-v0.4.4>)。这是面向 RC 运行时的 Pre-release；npm 主包单独安装不能替代七包组合。以随包 `validation.json` 的目标版本、启动结果与清理结果为准；没有 PASS 记录的组合不得安装。不自动升级或重启真实 Desktop。
+组合标识：`dsh-v0.2.2-rc.3-tasks-v0.4.5`。完整七包见[固定版本 Release](<https://github.com/chanyuenpang/dsh-better-tasks/releases/tag/dsh-v0.2.2-rc.3-tasks-v0.4.5>)。这是面向 RC 运行时的 Pre-release；npm 主包单独安装不能替代七包组合。以随包 `validation.json` 的目标版本、启动结果与清理结果为准；没有 PASS 记录的组合不得安装。不自动升级或重启真实 Desktop。
 
 ## 1. 先确认目标运行时
 
@@ -12,7 +12,7 @@ rc.2 用户保留 [Tasks 0.4.1 七包](<https://github.com/chanyuenpang/dsh-bett
 
 从固定版本 Release 下载全部独立资产（不是 GitHub 的 Source code ZIP），必须包含以下七包，及 `release-manifest.json`、`SHA256SUMS.txt`、`INSTALL.md`、`ROLLBACK.md`、`validation.json`：
 
-- `veewo-dsh-better-tasks-0.4.4.tgz`
+- `veewo-dsh-better-tasks-0.4.5.tgz`
 - `deepseek-ai-dsh-client-ui-layout-0.2.2-rc.3.tgz`
 - `deepseek-ai-dsh-client-ui-workspace-0.2.2-rc.3.tgz`
 - `deepseek-ai-dsh-client-ui-user-questions-0.2.2-rc.3.tgz`
@@ -25,16 +25,16 @@ rc.2 用户保留 [Tasks 0.4.1 七包](<https://github.com/chanyuenpang/dsh-bett
 ```powershell
 $ErrorActionPreference = 'Stop'
 # 替换为刚解压且已经核对的组合目录；此步不修改 DSH。
-$downloadDir = (Resolve-Path './dsh-v0.2.2-rc.3-tasks-v0.4.4').Path
+$downloadDir = (Resolve-Path './dsh-v0.2.2-rc.3-tasks-v0.4.5').Path
 $manifest = Get-Content (Join-Path $downloadDir 'release-manifest.json') -Raw | ConvertFrom-Json
 $validation = Get-Content (Join-Path $downloadDir 'validation.json') -Raw | ConvertFrom-Json
-if ($manifest.tag -ne 'dsh-v0.2.2-rc.3-tasks-v0.4.4' -or
-    $manifest.dshVersion -ne '0.2.2-rc.3' -or $manifest.tasksVersion -ne '0.4.4' -or
+if ($manifest.tag -ne 'dsh-v0.2.2-rc.3-tasks-v0.4.5' -or
+    $manifest.dshVersion -ne '0.2.2-rc.3' -or $manifest.tasksVersion -ne '0.4.5' -or
     $validation.result -ne 'PASS' -or $validation.dshVersion -ne '0.2.2-rc.3' -or
     !$validation.cleanupComplete -or @($manifest.assets).Count -ne 7) {
     throw '候选版本、数量或启动验证不符；不要安装'
 }
-$expected = @('veewo-dsh-better-tasks-0.4.4.tgz')
+$expected = @('veewo-dsh-better-tasks-0.4.5.tgz')
 $expected += 'layout','workspace','user-questions','input-trigger','commands','conversation' |
     ForEach-Object { "deepseek-ai-dsh-client-ui-$_-0.2.2-rc.3.tgz" }
 if (@(Compare-Object ($expected | Sort-Object) (@($manifest.assets.filename) | Sort-Object)).Count) {
@@ -87,8 +87,8 @@ if ($LASTEXITCODE -ne 0) { throw '安装失败；保持 Desktop 停止并恢复
 
 手动启动同一套 rc.3 Desktop。启动证据仅确认核心 shell/侧栏/Session/Workspace/会话可激活，没有启动错误；**不代替用户功能和外观验收**。
 
-0.4.4 恢复 `sidebar.session.action` 原生 HOC 接点。没有可选 action 时新会话按钮不变；DeepSeek 会话导入仍是官方实验性可选 bundle，默认不由 Better Tasks 启用。需要时在插件页启用官方导入插件，其入口通过标准 HOC 出现在新会话行；工作区选择继续用官方 factory。创建会话权限不足时整行不渲染，Better Tasks 不拥有导入解析或 Session 持久化逻辑。
+0.4.5 恢复 `sidebar.session.action` 原生 HOC 接点。没有可选 action 时新会话按钮不变；DeepSeek 会话导入仍是官方实验性可选 bundle，默认不由 Better Tasks 启用。需要时在插件页启用官方导入插件，其入口通过标准 HOC 出现在新会话行；工作区选择继续用官方 factory。创建会话权限不足时整行不渲染，Better Tasks 不拥有导入解析或 Session 持久化逻辑。
 
-0.4.4 还修复任务卡仅按主 agent 判断 idle 的问题：原生目录中已知子/孙 agent 仍在运行时保持 running；最后一个停止后恢复 idle。选中的会话标题改为官方主题蓝色，适配两种标题强调方式，卡片本身仍保留原来的状态色。并行开发的排序重构不在本次组合中，六个 fork 沿用 0.4.2 已验证字节。
+0.4.5 还修复任务卡仅按主 agent 判断 idle 的问题：原生目录中已知子/孙 agent 仍在运行时保持 running；最后一个停止后恢复 idle。选中的会话标题改为官方主题蓝色，适配两种标题强调方式，卡片本身仍保留原来的状态色。本版已完整合入初始化和顺序持久化优化：恢复已保存的完整任务顺序，不再扫描 Session 目录/历史或计算首工作时间；新增、拖动、移除均持久化顺序，初始化显示“正在恢复任务顺序”，只有真实旧队列导入时才显示合并提示。旧字段保持可读、旧队列保持只读，既有旧数据不删除。详见[完整顺序合同](<task-order-persistence.md>)。六个 fork 仍沿用 0.4.2 已验证字节。
 
 请自行验收上述状态和选中标题、原生新会话、任务 Pin/排序、独立输入、问答和斜杠提交；遇到异常保留那次 Console 堆栈。回滚见随包 `ROLLBACK.md` 或[回滚说明](<rollback.md>)：先退出、恢复匹配 rc.3 的完整七包与配置；如退回 rc.2，必须把 DSH 运行时和原 rc.2 七包作为整体恢复，不能只降主包。会话、原生 Pin、排序、外观和设置数据不删除。

package/docs/release.md

@@ -3,8 +3,8 @@
 ## 当前公开组合与 tag 规则
 
 - DSH Desktop 运行时：**0.2.2-rc.3**。
-- Better Tasks npm/package 版本：**0.4.4**。
-- Git tag / GitHub Release：**`dsh-v0.2.2-rc.3-tasks-v0.4.4`**（Pre-release）。
+- Better Tasks npm/package 版本：**0.4.5**。
+- Git tag / GitHub Release：**`dsh-v0.2.2-rc.3-tasks-v0.4.5`**（Pre-release）。
 - 安装入口：[rc.3 安装说明](<install-rc3.md>)；旧 rc.2 / Tasks 0.4.1 的[安装说明](<install.md>)和资产保持不变，兼容表见 [README](<../README.md>)。
 
 今后统一使用 `dsh-v<DSH版本>-tasks-v<Tasks版本>`。DSH 版本写完整，保留 rc 后缀；Tasks 版本仍由插件自己的 manifest 管理。同一 Tasks 源码可适配多条 DSH 线，但每条线都要有独立验证的组合 Release。已发布的 tag 与资产 URL 不移动、不覆盖；内容变化应升 Tasks 版本并创建新组合 tag。面向 RC 运行时的本次组合标记为 GitHub Pre-release，不依赖全局 Latest 作为安装入口。
@@ -19,6 +19,8 @@
 
 ## 本次组合与历史内容
 
+0.4.5 / rc.3：在 0.4.4 的 subagent 活跃态和选中标题修复上，完整合入初始化优化、唯一完整顺序持久化及恢复/旧队列导入提示分离。排序不再调用 listSessions/listEvents 或读取历史首工作时间；旧 native-order schema 保持可读，旧队列只读，导入仍有副作用前栅栏与中断不重试规则。完整七包独立通过本轮启动门禁后交付；六个 fork 不改字节。0.4.4 tag 与资产保留，不覆盖。
+
 0.4.4 / rc.3：在已验证的 0.4.2 上修复子/孙 agent 活跃时任务卡误显示 idle，并用官方主题蓝色标识当前选中会话标题。主包更新，六个 fork 保留 0.4.2 的已验证字节；完整七包有独立最终组合启动证据。0.4.3 是已安装的本地先行候选，不覆盖它的本地包或既有 tag。并行开发的排序重构明确不在这次发布中。GitHub 分发完整七包；npm 只发布 `@veewo/dsh-better-tasks` 主包，不向上游 `@deepseek-ai` scope 发布 fork，且不表示 npm 单包可独立安装。
 
 0.4.2 / rc.3：主包声明 root/hoc 的 `sidebar.session.action`，把原生新会话内容作为第三参 children 交给渲染器；整行受创建权限保护，可选动作不增加服务硬依赖。六个 fork 按精确 rc.3 基线从最新 overlay/patch 重建，保留 workspace picker factory、问答回退、原生 Pin、导航与真实仲裁 Promise。候选使用新的完整七包、清单与独立 rc.3 Desktop 启动证据，不沿用旧 rc.3 库的接受结论。最终结果以随包 `validation.json` 为准。

package/docs/rollback.md

@@ -1,6 +1,8 @@
 # 卸载 / 回滚 Better Tasks
 
-## rc.3 / Tasks 0.4.4 回滚
+## rc.3 / Tasks 0.4.5 回滚
+
+0.4.5 合并初始化与完整顺序持久化优化；回到 0.4.4 应恢复该版本的完整七包与配置，保留现有 Session、原生 Pin 和存储。旧版不会自动恢复从未落盘的历史显示顺序；不要删除排序域或旧队列来“重置”升级。
 
 [rc.3 候选](<install-rc3.md>)必须整体保留主包与六个 rc.3 fork。安装失败时保持 Desktop 退出，恢复安装前 Profile 配置与同一运行时的完整七包；仅把主包降到 rc.2 的 0.4.1 不是合法回滚。若要退回 rc.2，须先恢复相应官方运行时，再恢复原 rc.2 / Tasks 0.4.1 七包，不能跨线混用。以下移除插件与六个 fork 的通用步骤同样适用；不删除任何 Session/Pin/排序/设置数据。
 

package/docs/task-order-persistence.md

@@ -0,0 +1,25 @@
+# 完整任务顺序持久化（Tasks 0.4.5）
+
+任务成员仍由官方 Workspace Pin 唯一拥有。Better Tasks 的 native-order v1 记录只维护完整顺序 sessionIds、已提交 revision 和一次性旧队列导入 journal，不拥有第二份成员集合。
+
+- 新 Pin 的成员插入完整顺序顶部并直接触发保存，不必先打开任务视图。同一快照批量新增保留快照顺序，连续新增事件后者在前。
+- 手动拖动保存完整顺序；取消 Pin/归档保存删除后的顺序。隐藏空白、子代理、冷目录项仍占持久位置，客户端过滤不能删除它们。
+- 启动按已保存 sessionIds 原序恢复，补入当前官方新增成员，剔除已移除成员。原生 Pin 数组的纯重排、消息、标题、工作时间及目录加载不会重排已有成员；已 Pin 空白转为非空也不二次提顶。
+- 排序不读取 listSessions/listEvents 或会话历史，不再计算首工作时间。旧 manualSessionIds/manualOrderAt/时间映射保持 schema 可读，但不再参与排序，新提交不再写这些字段。无法恢复旧版从未持久化的临时显示顺序。
+- 启动存储打开期间与写入期间保留有序成员变化，尤其取消 Pin 再重新 Pin 同一 ID 必须作为重新插入，不只采用最后一个成员集合。
+
+## 提交、失败与恢复
+
+所有顺序写入由同一 Host 队列串行执行。成功持久化后才推进 revision；拖动通过 expectedRevision CAS 拒绝过时请求。存储失败不改变官方 Pin，不推进已提交 revision，不伪报拖动成功。成员仍即时可见或移除，未保存的完整顺序保留在内存并显式告警，拖动暂停；后续 GET、焦点刷新或成员事件可重试，成功后清除瞬时错误。客户端刷新有界，不无限轮询。
+
+官方成员域和排序域没有公共原子事务：两者提交之间若进程崩溃，重启会从官方成员补齐缺项，但不能重建崩溃窗口内从未落盘的全部插入先后。不通过私有事务、回滚 Pin 或历史扫描猜测补救。
+
+## 旧队列与提示
+
+旧 better_tasks_pin_queue 保持只读。仅缺少 native-order 时尝试一次导入；保留 seed 顺序、先持久化 attempted 栅栏再调用官方 Pin、用户 touch/archive 优先、失败 partial、中断 uncertain 且不自动重试的规则。没有待导入成员时直接 done，不伪造 running。
+
+初始化显示“正在恢复任务顺序”；只有真正旧队列 running 才显示“正在合并已有置顶任务”。这不是所有外部存储或 Pin I/O 都有固定耗时上限的承诺。
+
+## 验证边界
+
+单元/合同覆盖旧记录原序恢复、查询零调用、未打开任务页即保存、插入/拖动/删除后重启、并发和重入、失败告警与恢复、旧队列安全导入及提示分离。真实 profile 修改前仍须精确候选隔离冷启动，关闭 Cindy、隔离全部存储、确认核心 shell 激活并清理；启动门禁不代替用户功能验收，不自动重启真实 Desktop。

package/lib/client.js

@@ -70,7 +70,9 @@ window.__ModuleLoader__.load({
       const stopTimer = () => { if (timer !== undefined) { cancel(timer); timer = undefined } }
       const armMigrationRefresh = () => {
         stopTimer()
-        if (!started || disposed || !['pending', 'initializing', 'running'].includes(migration?.status)) { polls = 0; return }
+        const restoring = ['pending', 'initializing', 'running'].includes(migration?.status)
+        const saving = loaded && !writable && ['done', 'partial'].includes(migration?.status)
+        if (!started || disposed || !(restoring || saving)) { polls = 0; return }
         if (polls >= 60) return // Native follow/focus still refresh; never poll indefinitely after a stuck migration.
         polls++
         timer = schedule(() => { timer = undefined; void refresh().catch(() => {}) }, 1000)
@@ -118,17 +120,6 @@ window.__ModuleLoader__.load({
         }
         binding = next; generation++
         let signature, closed = false
-        let visible = new Set()
-        const observeStartedTasks = () => {
-          if (closed || disposed || !nativeReady()) return
-          const sessions = next.sessions?.getSnapshot?.()
-          if (sessions?.phase !== 'ready') return
-          const nextVisible = new Set(native.pinnedSessionIds.filter(id => sessions.byId?.[id]?.blank === false))
-          const appeared = [...nextVisible].some(id => !visible.has(id))
-          visible = nextVisible
-          // A pre-existing Pin can become a new task without a workspace change.
-          if (appeared && started) void refresh().catch(() => {})
-        }
         const observe = () => {
           if (closed || disposed) return
           const snapshot = next.source.getSnapshot()
@@ -136,14 +127,12 @@ window.__ModuleLoader__.load({
           const value = JSON.stringify([native.pinnedSessionIds, native.archivedSessionIds, native.phase, native.state])
           const changed = signature !== value
           signature = value; publish()
-          observeStartedTasks()
           if (changed && nativeReady() && started) void refresh().catch(() => {})
         }
         const off = next.source.subscribe(observe)
-        const offSessions = typeof next.sessions?.subscribe === 'function' ? next.sessions.subscribe(observeStartedTasks) : () => {}
         disconnect = () => {
           if (closed) return
-          closed = true; off(); offSessions(); stopTimer(); generation++
+          closed = true; off(); stopTimer(); generation++
           if (binding === next) { binding = undefined; native = undefined; loaded = false; writable = false; publish() }
         }
         observe()
@@ -174,7 +163,7 @@ window.__ModuleLoader__.load({
         actionError = null; countPending(sessionId, 1)
         return enqueue(async () => {
           if (!loaded || !writable) await readOrder()
-          if (!writable) throw new Error('Task order is not ready; pin migration may still be running')
+          if (!writable) throw new Error('Task order is not ready or has not been saved; official Pin remains usable')
           for (let attempt = 0; attempt < 2; attempt++) {
             const queue = source.getSnapshot().queue
             if (!queue.sessionIds.includes(sessionId) || beforeSessionId != null && !queue.sessionIds.includes(beforeSessionId)) throw new Error('Task is no longer pinned')
@@ -856,7 +845,7 @@ window.__ModuleLoader__.load({
      * browser's localStorage is an append log, so records from earlier builds stay
      * forever and only payloads whose revision matches the delivered build count.
      */
-    const BUILD_REVISION = '4f0d9b3936354d5636750c6b21756510b82d9a276f1aab5d8d701e9bccfef3dc'
+    const BUILD_REVISION = 'da11927b17db72c2a819ac8fc74933039cf592c8ba30b2b9efc45149c0b9c0ca'
     /** Render probe: on by default, so a delivered build can prove the column rendered. */
     const RENDER_PROBE = true
     /** Per-render payload; rewritten on every invocation. */
@@ -964,6 +953,7 @@ window.__ModuleLoader__.load({
         'tasks.todoInProgress': '进行中',
         'tasks.todoPending': '待处理',
         'tasks.empty': '还没有置顶会话',
+        'tasks.orderRestoring': '正在恢复任务顺序…',
         'tasks.pinMigration': '正在合并已有置顶任务…',
         'tasks.expandGoal': '展开 Goal',
         'tasks.collapseGoal': '收起 Goal',
@@ -1068,6 +1058,7 @@ window.__ModuleLoader__.load({
         'tasks.todoInProgress': 'In progress',
         'tasks.todoPending': 'Pending',
         'tasks.empty': 'No pinned sessions yet',
+        'tasks.orderRestoring': 'Restoring task order…',
         'tasks.pinMigration': 'Importing existing pinned tasks…',
         'tasks.expandGoal': 'Expand Goal',
         'tasks.collapseGoal': 'Collapse Goal',
@@ -2209,7 +2200,8 @@ window.__ModuleLoader__.load({
         style: { '--dbt-projection-font-size': `${preferences.detailFontSize}px` },
       },
         appearanceState.status === 'unavailable' ? element('div', { className: 'dbt-task-warning', role: 'status' }, t('tasks.appearanceUnavailable')) : null,
-        ['initializing', 'running'].includes(taskPins.migration) ? element('div', { className: 'dbt-task-warning', role: 'status' }, t('tasks.pinMigration')) : null,
+        taskPins.migration === 'initializing' ? element('div', { className: 'dbt-task-warning', role: 'status' }, t('tasks.orderRestoring')) : null,
+        taskPins.migration === 'running' ? element('div', { className: 'dbt-task-warning', role: 'status' }, t('tasks.pinMigration')) : null,
         taskPins.error !== null || moveError !== '' ? element('div', { className: 'dbt-task-warning', role: 'status' }, moveError || taskPins.error) : null,
         actionWarning === '' ? null : element('div', { className: 'dbt-task-warning', role: 'alert' }, actionWarning),
         tasks.length === 0 ? element('div', { className: 'dbt-task-empty' }, t('tasks.empty')) :

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veewo/dsh-better-tasks",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "type": "module",
   "description": "DSH Desktop sidebar replacement with native pinned-task cards and independent task input surfaces.",
   "publishConfig": {
@@ -30,6 +30,7 @@
     "docs/sidebar-layout.md",
     "docs/rc2-slash-submit-catch.md",
     "docs/task-session-activity.md",
+    "docs/task-order-persistence.md",
     "docs/release.md",
     "docs/rollback.md"
   ],

package/src/client.js

@@ -139,6 +139,7 @@ const dictionaries = {
     'tasks.todoInProgress': '进行中',
     'tasks.todoPending': '待处理',
     'tasks.empty': '还没有置顶会话',
+    'tasks.orderRestoring': '正在恢复任务顺序…',
     'tasks.pinMigration': '正在合并已有置顶任务…',
     'tasks.expandGoal': '展开 Goal',
     'tasks.collapseGoal': '收起 Goal',
@@ -243,6 +244,7 @@ const dictionaries = {
     'tasks.todoInProgress': 'In progress',
     'tasks.todoPending': 'Pending',
     'tasks.empty': 'No pinned sessions yet',
+    'tasks.orderRestoring': 'Restoring task order…',
     'tasks.pinMigration': 'Importing existing pinned tasks…',
     'tasks.expandGoal': 'Expand Goal',
     'tasks.collapseGoal': 'Collapse Goal',
@@ -1384,7 +1386,8 @@ function TaskSwimlane({ useSessions, useWorkspaces, useSessionStatus, useTaskCon
     style: { '--dbt-projection-font-size': `${preferences.detailFontSize}px` },
   },
     appearanceState.status === 'unavailable' ? element('div', { className: 'dbt-task-warning', role: 'status' }, t('tasks.appearanceUnavailable')) : null,
-    ['initializing', 'running'].includes(taskPins.migration) ? element('div', { className: 'dbt-task-warning', role: 'status' }, t('tasks.pinMigration')) : null,
+    taskPins.migration === 'initializing' ? element('div', { className: 'dbt-task-warning', role: 'status' }, t('tasks.orderRestoring')) : null,
+    taskPins.migration === 'running' ? element('div', { className: 'dbt-task-warning', role: 'status' }, t('tasks.pinMigration')) : null,
     taskPins.error !== null || moveError !== '' ? element('div', { className: 'dbt-task-warning', role: 'status' }, moveError || taskPins.error) : null,
     actionWarning === '' ? null : element('div', { className: 'dbt-task-warning', role: 'alert' }, actionWarning),
     tasks.length === 0 ? element('div', { className: 'dbt-task-empty' }, t('tasks.empty')) :

package/src/index.js

@@ -9,7 +9,7 @@ import {
 } from './pin-model.mjs'
 import { installProjectAppearance } from './project-appearance.mjs'
 import { createFinalMessageHttpHandler } from './final-message.mjs'
-import { createNativePinHost, taskFirstWorkAt } from './native-pin-host.mjs'
+import { createNativePinHost } from './native-pin-host.mjs'
 import { createTaskExecutionProjection } from './task-execution.mjs'
 
 export const name = 'dsh-better-tasks'
@@ -75,10 +75,11 @@ export const pinQueueDomain = defineDomain({
 export const nativePinOrderDomain = defineDomain({
   name: 'better_tasks_native_order', version: 1,
   tables: { state: domainTable(pinQueueRecord.extend({
-    // Absent on older auto-seeded records; only an explicit drag writes this.
+    // Read compatibility only. sessionIds is the sole order; new writes omit
+    // the former manual subset and time-derived sorting metadata.
     manualSessionIds: z.array(z.string().min(1)).refine((ids) => new Set(ids).size === ids.length).optional(),
     manualOrderAt: z.number().int().nonnegative().optional(),
-    // Task admission time may differ from an older/reused Session header.
+    // Old admission/work caches are accepted, never read to determine order.
     taskCreatedAtBySession: z.record(z.string().min(1), z.number().int().nonnegative()).optional(),
     taskFirstWorkAtBySession: z.record(z.string().min(1), z.number().int().nonnegative()).optional(),
     migration: z.object({
@@ -194,9 +195,6 @@ export async function apply(ctx) {
   }
   const controller = createNativePinHost({
     registry: ctx.workspaceRegistry,
-    listSessions: (signal) => ctx.sessionQuery.listSessions(signal),
-    readTaskStartedAt: async (header, signal) => typeof ctx.sessionQuery.listEvents === 'function'
-      ? taskFirstWorkAt(await ctx.sessionQuery.listEvents(header.id, signal)) : undefined,
     openOrder: () => open(nativePinOrderDomain, 'state'),
     openLegacy: () => open(pinQueueDomain, 'queues'),
     subscribe: listener => ctx.on('domain/changed', listener),

package/src/native-pin-host.mjs

@@ -1,131 +1,75 @@
-// Official Workspace pins own membership. This controller owns rank and a sealed,
-// at-most-once legacy import journal only; it never compensates native operations.
+// Official Workspace pins own membership. This controller owns one complete order
+// and a sealed, at-most-once legacy import journal; it never compensates native Pin.
 const NATIVE_ORDER_KEY = 'global'
 const sameIds = (a, b) => a.length === b.length && a.every((id, index) => id === b[index])
 const ownedIds = value => {
   if (!Array.isArray(value) || value.some(id => typeof id !== 'string' || id === '') || new Set(value).size !== value.length) throw new Error('Invalid native pin/order identities')
   return [...value]
 }
-const projectIds = (rank, pins) => {
-  const pinned = new Set(pins), ranked = new Set(rank)
-  return [...rank.filter(id => pinned.has(id)), ...pins.filter(id => !ranked.has(id))]
-}
 const messageOf = error => String(error?.message ?? error).slice(0, 1000)
 const changedIds = (a, b) => {
   const before = new Set(a), after = new Set(b)
   return [...a.filter(id => !after.has(id)), ...b.filter(id => !before.has(id))]
 }
+// New members join the complete sequence immediately. Pure native array reorders
+// cannot move existing members; neither clocks nor Session content are involved.
+const mergeOrder = (sequence, pins, reserved = new Set()) => {
+  const members = new Set(pins), ranked = new Set(sequence)
+  return [...pins.filter(id => !ranked.has(id)), ...sequence.filter(id => members.has(id) || reserved.has(id))]
+}
 export class NativePinError extends Error {
   constructor(code, message, status = 400) { super(message); this.code = code; this.status = status }
 }
 
-/** First admitted work, not empty-file preparation time or later activity. */
-export function taskFirstWorkAt(events) {
-  for (const event of events) {
-    if (['agent/inbox/spliced', 'user/message', 'turn/start'].includes(event.type)
-      && Number.isSafeInteger(event.time) && event.time >= 0) return event.time
-  }
-  return undefined
-}
-
 /** open* returns {table,close}; subscribe returns an event unsubscriber. */
-export function createNativePinHost({ registry, openOrder, openLegacy, subscribe, listSessions, readTaskStartedAt, now = () => new Date().toISOString(), taskCreationNow = Date.now }) {
-  let pins = [], archived = [], rank = [], revision = 0, updatedAt = now(), epoch = 0
-  let phase = 'initializing', record, table, disposed = false, started = false, nativeValid = true
-  let tail = Promise.resolve(), initialization, migration, reconcileQueued = false
-  const handles = new Set(), touched = new Set(), warnings = [], warningSet = new Set()
+export function createNativePinHost({ registry, openOrder, openLegacy, subscribe, now = () => new Date().toISOString() }) {
+  let pins = [], archived = [], rank = [], sequence = [], revision = 0, updatedAt = now(), epoch = 0
+  let phase = 'initializing', record, table, disposed = false, started = false, nativeValid = true, hydrated = false
+  let tail = Promise.resolve(), initialization, migration, reconcileQueued = false, persistenceError = null
+  const snapshots = [], handles = new Set(), touched = new Set(), reservedIds = new Set(), warnings = [], warningSet = new Set()
   const warn = error => { const text = messageOf(error); if (!warningSet.has(text)) { warningSet.add(text); warnings.push(text); if (warnings.length > 30) warnings.shift() } }
   const enqueue = work => {
     const next = tail.then(() => { if (disposed) throw new NativePinError('better-tasks/closed', 'Task ordering is closed', 503); return work() })
     tail = next.catch(() => {})
     return next
   }
-  const createdAt = new Map(), firstWorkAt = new Map(), headers = new Map(), admittedHere = new Set(), lifetime = new AbortController()
-  let metadataDirty = false
-  const newestFirst = (ids) => [...ids].sort((a, b) => {
-    const left = createdAt.get(a), right = createdAt.get(b)
-    if (left === undefined || right === undefined) return left === right ? 0 : left === undefined ? 1 : -1
-    return right - left || (a < b ? -1 : a > b ? 1 : 0)
-  })
-  const orderedIds = () => {
-    const ids = projectIds(rank, pins)
-    if (record?.manualSessionIds === undefined) return newestFirst(ids)
-    const members = new Set(ids), manual = new Set(record.manualSessionIds)
-    // New tasks lead; an existing manual sequence never follows message activity.
-    return [...newestFirst(ids.filter(id => !manual.has(id))), ...record.manualSessionIds.filter(id => members.has(id))]
-  }
-  async function refreshCreatedAt() {
-    const before = orderedIds()
-    try {
-      if (typeof listSessions === 'function' && pins.some(id => !headers.has(id))) {
-        const rows = await listSessions(lifetime.signal)
-        if (disposed) return
-        for (const { header } of rows) if (pins.includes(header.id)) {
-          headers.set(header.id, header)
-          if (!createdAt.has(header.id) && Number.isSafeInteger(header.createdAt) && header.createdAt >= 0) createdAt.set(header.id, header.createdAt)
-        }
-      }
-      for (const id of [...pins]) {
-        const header = headers.get(id)
-        // Forks inherit parent work; their own creation header remains the key.
-        if (!header || header.isSeeded === true) continue
-        let timestamp = firstWorkAt.get(id)
-        if (timestamp === undefined && typeof readTaskStartedAt === 'function') {
-          try { timestamp = await readTaskStartedAt(header, lifetime.signal) }
-          catch (error) { if (!disposed) warn(error); continue }
-          if (disposed) return
-          if (!pins.includes(id) || !Number.isSafeInteger(timestamp) || timestamp < 0) continue
-          firstWorkAt.set(id, timestamp); metadataDirty = true
-          // Only work born after the manual decision leads. A delayed birth
-          // read must not override an explicit drag made after that work began.
-          const manualAt = record?.manualOrderAt ?? Date.parse(record?.updatedAt)
-          const newerThanManual = Number.isFinite(manualAt) ? timestamp > manualAt : phase === 'done' || phase === 'partial'
-          if (newerThanManual && record?.manualSessionIds?.includes(id)) {
-            record = { ...record, manualSessionIds: record.manualSessionIds.filter(value => value !== id) }
-          }
-        }
-        if (timestamp !== undefined) createdAt.set(id, Math.max(createdAt.get(id) ?? 0, timestamp))
-      }
-      for (const map of [createdAt, firstWorkAt, headers]) for (const id of map.keys()) if (!pins.includes(id)) map.delete(id)
-      if (!sameIds(before, orderedIds())) { revision++; updatedAt = now() }
-    } catch (error) { if (!disposed) warn(error) }
+  const orderedIds = () => sequence.filter(id => pins.includes(id))
+  const orderReady = () => !disposed && nativeValid && table !== undefined && (phase === 'done' || phase === 'partial')
+  const response = () => {
+    const errors = [...warnings, ...(persistenceError ? [persistenceError] : [])]
+    return {
+      queue: { schemaVersion: 1, revision, sessionIds: orderedIds(), updatedAt },
+      ...(errors.length ? { warnings: errors } : {}),
+      migration: { status: phase },
+      writable: orderReady() && !persistenceError && sameIds(rank, orderedIds()),
+    }
   }
-  const response = () => ({
-    queue: { schemaVersion: 1, revision, sessionIds: orderedIds(), updatedAt },
-    ...(warnings.length === 0 ? {} : { warnings: [...warnings] }),
-    migration: { status: phase }, writable: !disposed && nativeValid && table !== undefined && (phase === 'done' || phase === 'partial'),
-  })
+  const reservations = () => new Set([...reservedIds].filter(id => !touched.has(id) && !archived.includes(id)))
   const nativeSnapshot = (nextPins, nextArchived, observe = true) => {
-    const p = ownedIds(nextPins), a = ownedIds(nextArchived)
+    const a = ownedIds(nextArchived), excluded = new Set(a), p = ownedIds(nextPins).filter(id => !excluded.has(id))
     nativeValid = true
     if (sameIds(p, pins) && sameIds(a, archived)) return
+    const membershipChanged = changedIds(pins, p).length > 0 || changedIds(archived, a).length > 0
     if (observe) for (const id of [...changedIds(pins, p), ...changedIds(archived, a)]) touched.add(id)
-    const previous = projectIds(rank, pins)
-    // A newly admitted task goes first even if the native action reuses an old
-    // blank Session or its header is not in the metadata catalog yet. Only new
-    // membership counts; message/status updates and native pin-array order do not.
-    if (observe && phase !== 'running') {
-      const previousMembers = new Set(pins)
-      let admittedAt = taskCreationNow()
-      if (Number.isSafeInteger(admittedAt) && admittedAt >= 0) {
-        // A same-millisecond click must still precede the prior admission. This
-        // logical ordering key is never shown as a replacement Session date.
-        for (const timestamp of createdAt.values()) if (timestamp >= admittedAt && timestamp < Number.MAX_SAFE_INTEGER) admittedAt = timestamp + 1
-        for (const id of p) if (!previousMembers.has(id)) { createdAt.set(id, admittedAt); admittedHere.add(id) }
-      }
-    }
-    pins = p; archived = a; epoch++
-    if (!sameIds(previous, projectIds(rank, pins))) { revision++; updatedAt = now() }
+    pins = p; archived = a
+    if (!observe) { sequence = [...p]; return }
+    if (membershipChanged) epoch++
+    // Retain all transitions while opening storage, including Unpin -> Pin of
+    // the same id. One latest snapshot would lose its re-insertion position.
+    if (!hydrated) snapshots.push([...p])
+    sequence = mergeOrder(sequence, pins, reservations())
+    if (membershipChanged) start()
     scheduleReconcile()
   }
   function scheduleReconcile() {
-    if (!disposed && nativeValid && started && table !== undefined && (phase === 'done' || phase === 'partial') && !reconcileQueued) {
-      reconcileQueued = true
-      void enqueue(async () => { reconcileQueued = false; await refreshCreatedAt(); await reconcile() }).catch(error => { reconcileQueued = false; warn(error) })
-    }
+    if (!orderReady() || reconcileQueued) return
+    reconcileQueued = true
+    void enqueue(async () => {
+      try { await reconcile() } finally { reconcileQueued = false }
+    }).catch(() => {})
   }
-  // Storage emits before WorkspaceRegistry's private cache is assigned. Payload
-  // ownership is essential: never synchronously read registry getters here.
+  // Storage emits before WorkspaceRegistry's private cache is assigned. Always
+  // consume the owned event payload, never registry getters inside this callback.
   const off = subscribe(change => {
     if (disposed || change?.domain !== 'workspace' || change.table !== '' || change.key !== '' || change.operation !== 'put') return
     try { nativeSnapshot(change.value?.pinnedSessionIds, change.value?.archivedSessionIds) }
@@ -133,27 +77,31 @@ export function createNativePinHost({ registry, openOrder, openLegacy, subscribe
   })
   try { nativeSnapshot(registry.pinnedSessionIds, registry.archivedSessionIds, false) }
   catch (error) { nativeValid = false; warn(error); phase = 'error' }
-  const initiallyPinned = new Set(pins)
+  const initialPins = [...pins], initiallyPinned = new Set(pins)
 
   async function save(next) {
     const nextRank = ownedIds(next.sessionIds)
-    const nextRevision = Math.max(revision, record?.revision ?? 0) + (sameIds(rank, nextRank) ? 0 : 1)
-    const value = { ...next, schemaVersion: 1, revision: nextRevision, sessionIds: nextRank, updatedAt: now(),
-      taskCreatedAtBySession: Object.fromEntries([...createdAt].filter(([id]) => pins.includes(id))),
-      taskFirstWorkAtBySession: Object.fromEntries([...firstWorkAt].filter(([id]) => pins.includes(id))),
-      ...(next.manualSessionIds === undefined ? {} : { manualSessionIds: next.manualSessionIds.filter(id => pins.includes(id)) }) }
-    // A singleton owner plus this controller's tail owns all writes to this domain.
-    if (record === undefined) await table.put(NATIVE_ORDER_KEY, value)
-    else await table.update(NATIVE_ORDER_KEY, () => value)
-    metadataDirty = false
-    record = value; rank = [...value.sessionIds]; revision = Math.max(revision, value.revision); updatedAt = value.updatedAt
+    // Legacy fields remain readable in the v1 schema, but are no longer writers
+    // or authorities. Every new commit contains just one complete order.
+    const { manualSessionIds, manualOrderAt, taskCreatedAtBySession, taskFirstWorkAtBySession, ...base } = next
+    const value = { ...base, schemaVersion: 1, revision: revision + 1, sessionIds: nextRank, updatedAt: now() }
+    try {
+      if (record === undefined) await table.put(NATIVE_ORDER_KEY, value)
+      else await table.update(NATIVE_ORDER_KEY, () => value)
+    } catch (error) {
+      persistenceError = 'Task order was not saved; official Pin membership is unchanged: ' + messageOf(error)
+      throw error
+    }
+    // Never advance a committed revision/rank before storage acknowledges. The
+    // live sequence may already include newer events received during this write.
+    record = value; rank = [...value.sessionIds]; revision = value.revision; updatedAt = value.updatedAt
+    persistenceError = null
     return value
   }
   async function reconcile() {
-    if (record === undefined || phase === 'initializing' || phase === 'running') return
-    const ids = orderedIds()
-    if (sameIds(ids, rank) && record.revision === revision && !metadataDirty) return
-    await save({ ...record, sessionIds: ids })
+    if (!orderReady() || record === undefined) return
+    while (!sameIds(rank, orderedIds())) await save({ ...record, sessionIds: orderedIds() })
+    persistenceError = null
   }
   async function open(factory) {
     const handle = await factory()
@@ -162,7 +110,7 @@ export function createNativePinHost({ registry, openOrder, openLegacy, subscribe
     return handle
   }
   async function close(handle) { if (!handles.delete(handle)) return; await handle.close() }
-  const replaceEntry = (id, patch) => ({ ...record, migration: { ...record.migration,
+  const replaceEntry = (id, patch) => ({ ...record, sessionIds: [...sequence], migration: { ...record.migration,
     entries: record.migration.entries.map(entry => entry.sessionId === id ? { ...entry, ...patch } : entry) } })
 
   async function runMigration() {
@@ -190,7 +138,7 @@ export function createNativePinHost({ registry, openOrder, openLegacy, subscribe
         } catch (error) {
           const known = error?.name === 'WorkspaceUnknownSessionError' || error?.name === 'WorkspaceArchivedSessionPinError'
           outcome = { status: known ? 'skipped' : 'failed', detail: messageOf(error) }
-          warn(`Legacy task ${entry.sessionId} was not imported: ${outcome.detail}`)
+          warn('Legacy task ' + entry.sessionId + ' was not imported: ' + outcome.detail)
         }
         await save(replaceEntry(entry.sessionId, outcome))
       })
@@ -199,38 +147,38 @@ export function createNativePinHost({ registry, openOrder, openLegacy, subscribe
     await enqueue(async () => {
       const partial = record.migration.entries.some(entry => entry.status === 'failed' || entry.status === 'attempted')
       const status = partial ? 'partial' : 'done'
-      // Until now legacy seed rank was retained even for not-yet-imported ids.
-      await refreshCreatedAt()
-      await save({ ...record, sessionIds: orderedIds(), migration: { ...record.migration, status } })
+      reservedIds.clear()
+      sequence = orderedIds() // Remove only the unimported reservations.
+      await save({ ...record, sessionIds: [...sequence], migration: { ...record.migration, status } })
       phase = status
+      await reconcile()
     })
   }
+  function hydrate(base, reserved = new Set()) {
+    for (const id of reserved) reservedIds.add(id)
+    sequence = mergeOrder(base, initialPins, reserved)
+    for (const snapshot of snapshots) sequence = mergeOrder(sequence, snapshot, reserved)
+    snapshots.length = 0; hydrated = true
+  }
   async function initialize() {
     if (!nativeValid) throw new Error('Native pin state is unavailable')
     const order = await open(openOrder); table = order.table
     const stored = table.get(NATIVE_ORDER_KEY)
     if (stored !== undefined) {
-      rank = ownedIds(stored.sessionIds); record = stored; revision = Math.max(revision, stored.revision); updatedAt = stored.updatedAt
-      for (const [id, timestamp] of Object.entries(stored.taskCreatedAtBySession ?? {})) {
-        if (pins.includes(id) && !admittedHere.has(id) && Number.isSafeInteger(timestamp) && timestamp >= 0) createdAt.set(id, timestamp)
-      }
-      for (const [id, timestamp] of Object.entries(stored.taskFirstWorkAtBySession ?? {})) {
-        if (pins.includes(id) && Number.isSafeInteger(timestamp) && timestamp >= 0) firstWorkAt.set(id, timestamp)
-      }
-      await refreshCreatedAt()
-      for (const entry of stored.migration.entries) if (entry.detail && (entry.status === 'failed' || entry.status === 'uncertain')) warn(`Legacy task ${entry.sessionId}: ${entry.detail}`)
+      rank = ownedIds(stored.sessionIds); record = stored; revision = stored.revision; updatedAt = stored.updatedAt
+      hydrate(rank)
+      for (const entry of stored.migration.entries) if (entry.detail && (entry.status === 'failed' || entry.status === 'uncertain')) warn('Legacy task ' + entry.sessionId + ': ' + entry.detail)
       if (stored.migration.status === 'running') {
         warn('Legacy pin migration was interrupted; unconfirmed entries will not be retried automatically. The original queue is preserved.')
         await enqueue(async () => {
-          await save({ ...record, sessionIds: projectIds(rank, pins), migration: { ...record.migration, status: 'partial', entries: record.migration.entries.map(entry => entry.status === 'pending' || entry.status === 'attempted' ? { ...entry, status: 'uncertain', detail: 'Interrupted import; use the official Pin control to recover explicitly' } : entry) } })
+          await save({ ...record, sessionIds: orderedIds(), migration: { ...record.migration, status: 'partial', entries: record.migration.entries.map(entry => entry.status === 'pending' || entry.status === 'attempted' ? { ...entry, status: 'uncertain', detail: 'Interrupted import; use the official Pin control to recover explicitly' } : entry) } })
         })
         phase = 'partial'
       } else phase = stored.migration.status
       await enqueue(reconcile)
       return
     }
-    await refreshCreatedAt()
-    // The legacy unit is opened with its unchanged v1 schema, read, then closed.
+    // The legacy unit is opened unchanged, read and closed; never erase its data.
     const legacy = await open(openLegacy)
     let seed
     try { seed = legacy.table.get(NATIVE_ORDER_KEY); if (seed !== undefined) ownedIds(seed.sessionIds) }
@@ -240,17 +188,25 @@ export function createNativePinHost({ registry, openOrder, openLegacy, subscribe
       status: alreadyNative.has(sessionId) || touched.has(sessionId) || archived.includes(sessionId) ? 'skipped' : 'pending',
       ...(alreadyNative.has(sessionId) ? { detail: 'Already officially pinned; never an import target' } : {}),
     }))
+    const pending = new Set(entries.filter(entry => entry.status === 'pending').map(entry => entry.sessionId))
+    hydrate([...seedIds, ...initialPins.filter(id => !seedIds.includes(id))], pending)
+    // No old import work means no fake migration phase or extra journal writes.
+    const status = pending.size ? 'running' : 'done'
     await enqueue(async () => {
-      await save({ schemaVersion: 1, revision, sessionIds: [...seedIds, ...pins.filter(id => !seedIds.includes(id))], updatedAt: now(),
-        migration: { status: 'running', sourceRevision: seed?.revision ?? null, entries } })
-      phase = 'running'
+      await save({ sessionIds: [...sequence], migration: { status, sourceRevision: seed?.revision ?? null, entries } })
+      phase = status
+      if (status === 'done') await reconcile()
     })
-    migration = runMigration().catch(error => { if (!disposed) { warn(`Legacy migration stopped: ${messageOf(error)}. The original queue is preserved.`); phase = 'error' } })
+    if (status === 'running') migration = runMigration().catch(error => { if (!disposed) { warn('Legacy migration stopped: ' + messageOf(error) + '. The original queue is preserved.'); phase = 'error' } })
   }
-  const start = () => {
+  function start() {
     if (started || disposed) return
     started = true; phase = 'initializing'
-    initialization = initialize().catch(error => { if (!disposed) { phase = 'error'; warn(`Task order initialization failed: ${messageOf(error)}`) } })
+    initialization = initialize().catch(error => {
+      // A loaded terminal journal with a dirty sequence can retry a failed save.
+      // Opening/fencing/import failures remain terminal and must not replay Pin.
+      if (!disposed && !orderReady()) { phase = 'error'; warn('Task order initialization failed: ' + messageOf(error)) }
+    })
   }
   function requireCommand(command) {
     if (command === null || typeof command !== 'object' || typeof command.sessionId !== 'string' || command.sessionId === '') throw new NativePinError('better-tasks/invalid-request', 'A Session identity is required')
@@ -261,25 +217,20 @@ export function createNativePinHost({ registry, openOrder, openLegacy, subscribe
     current: response,
     async mutate(command) {
       requireCommand(command)
-      // Explicit compatibility intent also counts when the native call will be
-      // an idempotent no-op and therefore emit no workspace change event.
       if (command.action !== 'move') touched.add(command.sessionId)
       start()
-      // Do not queue a move behind an in-flight migration I/O operation merely
-      // to return the already-known initializing/readonly state afterwards.
-      if (command.action === 'move' && !response().writable) throw new NativePinError('better-tasks/order-unavailable', 'Task ordering is initializing, migrating or unavailable; official Pin remains usable', 503)
+      if (command.action === 'move' && !orderReady()) throw new NativePinError('better-tasks/order-unavailable', 'Task order is initializing, importing or unavailable; official Pin remains usable', 503)
       return enqueue(async () => {
         if (command.action !== 'move') {
-          // Compatibility for old clients; all new UI uses official public controls.
           const observedEpoch = epoch
           if (command.action === 'unpin') await registry.unpinSession(command.sessionId)
           else await registry.pinSession(command.sessionId)
           if (observedEpoch === epoch) nativeSnapshot(registry.pinnedSessionIds, registry.archivedSessionIds)
-          try { await reconcile() } catch (error) { warn(`Native pin change succeeded, but task order could not be saved: ${messageOf(error)}`) }
+          try { await reconcile() } catch { /* save exposes persistenceError; never undo the native result. */ }
           return response()
         }
         if (!Number.isSafeInteger(command.expectedRevision) || command.expectedRevision < 0) throw new NativePinError('better-tasks/invalid-request', 'expectedRevision must be a non-negative safe integer')
-        if (!response().writable) throw new NativePinError('better-tasks/order-unavailable', 'Task ordering is initializing, migrating or unavailable; official Pin remains usable', 503)
+        if (!orderReady()) throw new NativePinError('better-tasks/order-unavailable', 'Task ordering is unavailable; official Pin remains usable', 503)
         await reconcile()
         if (command.expectedRevision !== revision) throw new NativePinError('better-tasks/revision-conflict', 'Task order changed', 409)
         const ids = orderedIds(), before = command.beforeSessionId ?? null
@@ -290,18 +241,19 @@ export function createNativePinHost({ registry, openOrder, openLegacy, subscribe
         next.splice(before === null ? next.length : next.indexOf(before), 0, command.sessionId)
         if (sameIds(next, ids)) return response()
         const observedEpoch = epoch
-        await save({ ...record, sessionIds: next, manualSessionIds: next, manualOrderAt: taskCreationNow() })
+        await save({ ...record, sessionIds: next })
         if (observedEpoch !== epoch) {
           await reconcile()
           throw new NativePinError('better-tasks/revision-conflict', 'Official membership changed while saving task order', 409)
         }
+        sequence = next
         return response()
       })
     },
     async settled() { await initialization; await migration; await tail },
     async dispose() {
       if (disposed) return
-      disposed = true; lifetime.abort(); off?.()
+      disposed = true; off?.()
       await initialization; await migration; await tail
       await Promise.all([...handles].map(close))
     },

package/src/pin-client.mjs

@@ -67,7 +67,9 @@ export function createTaskPinsClient({ request = pinRequest, schedule = setTimeo
   const stopTimer = () => { if (timer !== undefined) { cancel(timer); timer = undefined } }
   const armMigrationRefresh = () => {
     stopTimer()
-    if (!started || disposed || !['pending', 'initializing', 'running'].includes(migration?.status)) { polls = 0; return }
+    const restoring = ['pending', 'initializing', 'running'].includes(migration?.status)
+    const saving = loaded && !writable && ['done', 'partial'].includes(migration?.status)
+    if (!started || disposed || !(restoring || saving)) { polls = 0; return }
     if (polls >= 60) return // Native follow/focus still refresh; never poll indefinitely after a stuck migration.
     polls++
     timer = schedule(() => { timer = undefined; void refresh().catch(() => {}) }, 1000)
@@ -115,17 +117,6 @@ export function createTaskPinsClient({ request = pinRequest, schedule = setTimeo
     }
     binding = next; generation++
     let signature, closed = false
-    let visible = new Set()
-    const observeStartedTasks = () => {
-      if (closed || disposed || !nativeReady()) return
-      const sessions = next.sessions?.getSnapshot?.()
-      if (sessions?.phase !== 'ready') return
-      const nextVisible = new Set(native.pinnedSessionIds.filter(id => sessions.byId?.[id]?.blank === false))
-      const appeared = [...nextVisible].some(id => !visible.has(id))
-      visible = nextVisible
-      // A pre-existing Pin can become a new task without a workspace change.
-      if (appeared && started) void refresh().catch(() => {})
-    }
     const observe = () => {
       if (closed || disposed) return
       const snapshot = next.source.getSnapshot()
@@ -133,14 +124,12 @@ export function createTaskPinsClient({ request = pinRequest, schedule = setTimeo
       const value = JSON.stringify([native.pinnedSessionIds, native.archivedSessionIds, native.phase, native.state])
       const changed = signature !== value
       signature = value; publish()
-      observeStartedTasks()
       if (changed && nativeReady() && started) void refresh().catch(() => {})
     }
     const off = next.source.subscribe(observe)
-    const offSessions = typeof next.sessions?.subscribe === 'function' ? next.sessions.subscribe(observeStartedTasks) : () => {}
     disconnect = () => {
       if (closed) return
-      closed = true; off(); offSessions(); stopTimer(); generation++
+      closed = true; off(); stopTimer(); generation++
       if (binding === next) { binding = undefined; native = undefined; loaded = false; writable = false; publish() }
     }
     observe()
@@ -171,7 +160,7 @@ export function createTaskPinsClient({ request = pinRequest, schedule = setTimeo
     actionError = null; countPending(sessionId, 1)
     return enqueue(async () => {
       if (!loaded || !writable) await readOrder()
-      if (!writable) throw new Error('Task order is not ready; pin migration may still be running')
+      if (!writable) throw new Error('Task order is not ready or has not been saved; official Pin remains usable')
       for (let attempt = 0; attempt < 2; attempt++) {
         const queue = source.getSnapshot().queue
         if (!queue.sessionIds.includes(sessionId) || beforeSessionId != null && !queue.sessionIds.includes(beforeSessionId)) throw new Error('Task is no longer pinned')