fix(wework): preserve unread state across restarts

docs/en/wegent/developer-guide/local-device-architecture.md

@@ -85,7 +85,7 @@ If a user creates a Goal while a normal turn is still running, Wework retains th
 
 The Wework frontend manages every task lifecycle through one user-scoped `RuntimeTaskLifecycleStore`. The Store owns one state machine per task and routes events to it. The state machine is the aggregate root for execution, turn, Goal, and unread state; its reducer is only an internal transition implementation. The React Provider adapts that same Store for subscription and neither stores nor infers execution state. The task list, composer, message thinking feedback, system tray, close guard, and completion reminders all read the same Store snapshot.
 
-Frontend execution state is memory-only and is never written to a local file or browser storage. The optimistic `starting` state created when a user sends a message is owned by the same state machine and converges when the executor explicitly reports `running=true` or `running=false`. During automatic continuation of an active Goal, the task remains visibly running between turns and after a page reload while either local execution remains active or the provider still reports an `inProgress` turn. A turn without streaming content may remain `idle`, so Wework shows no thinking indicator and creates no unread marker. Only unread completion reminders are persisted, and they can never be used to infer execution state.
+Authoritative frontend execution state is memory-only and is never written to a local file or browser storage. The optimistic `starting` state created when a user sends a message is owned by the same state machine and converges when the executor explicitly reports `running=true` or `running=false`. During automatic continuation of an active Goal, the task remains visibly running between turns and after a page reload while either local execution remains active or the provider still reports an `inProgress` turn. A turn without streaming content may remain `idle`, so Wework shows no thinking indicator and creates no unread marker. To preserve unread edge detection across an application restart, Wework persists only task keys for unread results and task keys that were last observed running. The latter is not an execution-state source and cannot override the executor's current snapshot.
 
 Before a normal follow-up on a persistent thread calls `turn/start`, it must use `thread/read` to confirm that no active turn exists. Ephemeral threads do not support `thread/read(includeTurns)`, so their sends must instead check the executor's local active execution inside a per-task serialized critical section. A new turn must register itself as locally running before a concurrent sender can leave that section. If the provider rejects an overlapping send, Wework immediately restores the task to running state, refreshes the work list, and preserves the user's input in the queue. Once the provider settles to idle, Wework automatically sends that queued item with the same client message ID to avoid loss or duplication. Completion or interruption clears the active turn and restores the UI to idle. Interrupt-and-send creates a new turn only after the previous turn is confirmed interrupted: persistent threads also confirm that the provider turn stopped, while ephemeral threads rely on interruption of the local execution.
 

docs/en/wework/developer-guide/wework-chat-state-sources.md

@@ -242,7 +242,16 @@ The sidebar running indicator, composer state, message state, and unread reminde
 
 A terminal task event must immediately mark the local task as `running: false` and refresh the work list. If a concurrent refresh returns an older `running: true` snapshot, the reducer must preserve the locally settled state until the same task receives a new start event; a stale response must not relight the spinner, pause button, or "Thinking". Execution identity is `deviceId + taskId`. `workspacePath` is routing metadata that may change between creation, refresh, and transcript recovery, so it must not participate in execution-state identity.
 
-Unread is created only when the current Wework renderer observes a `running: true -> false` edge. It must not infer execution history from free-form `status` text or persisted records; local persistence stores only unread results that were already created, never running state. A task whose persisted Goal remains `active` while the executor is no longer running is waiting for recovery and must not become completion-unread because the application or executor restarted. The current task and every running task must be excluded from visible unread state. Opening a task clears its unread state.
+Unread is created only from a running-state edge for the same task: it was
+`running: true`, it is now `running: false`, and it is not the currently open
+task. Browser storage keeps task keys for unread results and, separately, task
+keys that were last observed running so Wework can finish this edge comparison
+after an abnormal application exit. The latter set exists only for unread
+reminders and is not a source of current execution state; executor snapshots
+and live events remain authoritative. The current task and every running task
+must be excluded from visible unread state, and opening a task clears its unread
+state. The new storage namespace does not import legacy unread data, so existing
+tasks start read after the upgrade.
 
 The executor's `RuntimeTaskLink.running` field exists only in current-process
 memory and runtime API responses. `runtime-work/index.json` must not serialize

docs/zh/wegent/developer-guide/local-device-architecture.md

@@ -85,7 +85,7 @@ Wework 的本地可用状态以真实 Codex app-server 完成 `initialize` 为
 
 Wework 前端通过一个用户级 `RuntimeTaskLifecycleStore` 管理所有任务生命周期；Store 为每个任务维护一个状态机并负责事件路由，状态机是执行状态、回合状态、Goal 状态和未读状态的聚合根，reducer 仅作为状态机内部的状态转换实现。React Provider 只把同一个 Store 适配为订阅，不保存或推断运行状态。任务列表、输入框、消息思考态、系统托盘、关闭保护和完成提醒都读取该 Store 的同一份快照。
 
-前端运行状态只保存在内存中，不写入本地文件或浏览器存储。用户发送消息时的乐观 `starting` 也由同一个状态机维护，并在 executor 明确返回 `running=true` 或 `running=false` 后收敛。Active Goal 自动续轮时，只要本地执行仍活跃或 provider 仍返回 `inProgress` turn，两轮之间和页面重载后都保持任务运行中；回合没有流式内容时可以为 `idle`，因此不显示“正在思考”也不产生未读。只有未读完成提醒会持久化，且不能反向推断运行状态。
+前端的权威运行状态只保存在内存中，不写入本地文件或浏览器存储。用户发送消息时的乐观 `starting` 也由同一个状态机维护，并在 executor 明确返回 `running=true` 或 `running=false` 后收敛。Active Goal 自动续轮时，只要本地执行仍活跃或 provider 仍返回 `inProgress` turn，两轮之间和页面重载后都保持任务运行中；回合没有流式内容时可以为 `idle`，因此不显示“正在思考”也不产生未读。为支持应用重启后的未读边沿判断，Wework 仅持久化已经产生的未读任务键和上一次观察到仍在运行的任务键；后者不是运行状态来源，不能覆盖 executor 的当前快照。
 
 普通持久线程续聊在调用 `turn/start` 前必须通过 `thread/read` 确认当前没有活跃 turn。ephemeral 临时线程不支持 `thread/read(includeTurns)`，因此必须在按任务串行化的发送临界区内检查 executor 本地活跃执行；新 turn 必须先登记为本地运行中，后一个并发发送才能离开临界区。若 provider 拒绝重叠发送，Wework 将任务状态立即恢复为运行中、刷新任务列表，并把用户输入保留在队列；provider 收敛为空闲后复用同一个客户端消息 ID 自动发送，避免丢消息或重复消息。完成或中断事件会清除活跃 turn 并使界面恢复为空闲。“打断并发送”只有在旧 turn 已确认中断后才创建新 turn；持久线程还要确认 provider turn 已停止，ephemeral 临时线程则以本地执行中断为准。
 

docs/zh/wework/developer-guide/wework-chat-state-sources.md

@@ -199,7 +199,13 @@ turn 被取消后 goal 在暂停请求到达前启动下一 turn。如果 goal 
 
 任务终止事件应立即把本地任务标记为 `running: false`，并刷新 work list。若并发刷新返回了更早的 `running: true` 快照，reducer 必须保留本地已结算状态，直到同一任务收到新的启动事件，不能让旧响应把 spinner、暂停按钮或“正在思考”重新点亮。同一任务的执行身份由 `deviceId + taskId` 决定；`workspacePath` 是可能在创建、刷新和 transcript 恢复间变化的路由元数据，不能参与运行状态身份判断。
 
-未读只在当前 Wework renderer 生命周期内观察到 `running: true -> false` 边沿时产生，不根据 `status` 文本或持久化记录猜测运行历史；本地持久化只保存已经产生的未读结果，不保存运行态。持久化 Goal 仍为 `active` 但 executor 已不再运行的任务属于待恢复状态，不得因应用或 executor 重启产生完成未读。当前任务和所有运行中任务都必须从可见未读集合排除；打开任务会清除其未读状态。
+未读只根据同一任务的运行状态边沿产生：之前为 `running: true`、现在为
+`running: false`，且任务不是当前打开任务。Wework 在浏览器存储中保存已经产生的
+未读任务键，并额外保存上一次观察到仍在运行的任务键，使应用异常退出后仍能在
+下次启动时完成这次边沿判断。这份任务键集合只服务于未读提醒，不能作为当前运行态
+来源；当前运行态仍以 executor 快照和实时事件为准。当前任务和所有运行中任务都必须
+从可见未读集合排除；打开任务会清除其未读状态。新存储命名空间不导入旧版未读数据，
+因此升级后的既有任务默认已读。
 
 executor 的 `RuntimeTaskLink.running` 只存在于当前进程内存和 runtime API
 响应中。`runtime-work/index.json` 不得序列化该字段，读取旧索引时也必须忽略其中

wework/src/features/workbench/runtimeTaskLifecycle/RuntimeTaskLifecycleStore.test.ts

@@ -845,7 +845,48 @@ describe('RuntimeTaskLifecycleStore', () => {
     expect(snapshot?.derived.shouldShowSidebarRunning).toBe(true)
   })
 
-  test('marks only background non-Goal completion unread and clears it when opened', () => {
+  test('marks a running task unread when startup reconciliation settles it', () => {
+    const store = new RuntimeTaskLifecycleStore('test')
+    store.syncRuntimeWork(runtimeWork(task({ running: true })))
+    store.syncRuntimeWork(runtimeWork(task({ running: true })))
+
+    store.syncRuntimeTranscriptSnapshot(address, {
+      running: false,
+      turns: [
+        {
+          id: 'restored-turn',
+          items: [],
+          status: 'completed',
+          completedAt: 1_786_692_066_192,
+        },
+      ],
+    })
+
+    expect(store.getTask(address)?.derived.shouldShowUnread).toBe(true)
+  })
+
+  test('marks work interrupted by an app restart unread', () => {
+    const previousStore = new RuntimeTaskLifecycleStore('test')
+    previousStore.syncRuntimeWork(runtimeWork(task()))
+    previousStore.executorStarted(address)
+
+    const restoredStore = new RuntimeTaskLifecycleStore('test')
+    restoredStore.syncRuntimeWork(
+      runtimeWork(
+        task({
+          running: false,
+          status: 'cancelled',
+          completedAt: 1_786_692_066_192,
+          turnStatus: 'interrupted',
+        })
+      )
+    )
+
+    expect(restoredStore.getTask(address)?.derived.shouldShowUnread).toBe(true)
+    expect(localStorage.getItem('wework.runtimeTaskLifecycle.test.running')).toBe('[]')
+  })
+
+  test('marks background non-Goal completion unread and clears it when opened', () => {
     const store = new RuntimeTaskLifecycleStore('test')
     store.syncRuntimeWork(runtimeWork(task({ running: true })))
     store.executorSettled(address)
@@ -912,9 +953,15 @@ describe('RuntimeTaskLifecycleStore', () => {
     const listener = vi.fn()
     store.subscribe(listener)
     const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
-    const setItem = vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
-      throw new Error('storage unavailable')
-    })
+    const originalSetItem = Storage.prototype.setItem
+    const setItem = vi
+      .spyOn(Storage.prototype, 'setItem')
+      .mockImplementation(function (key, value) {
+        if (key === 'wework.runtimeTaskLifecycle.test.unread') {
+          throw new Error('storage unavailable')
+        }
+        return originalSetItem.call(this, key, value)
+      })
 
     store.executorSettled(address)
 
@@ -933,7 +980,9 @@ describe('RuntimeTaskLifecycleStore', () => {
     store.executorSettled(address)
     store.goalStatusReceived(address, 'paused')
 
-    expect(setItem).toHaveBeenCalledOnce()
+    expect(
+      setItem.mock.calls.filter(([key]) => key === 'wework.runtimeTaskLifecycle.test.unread')
+    ).toHaveLength(1)
     setItem.mockRestore()
   })
 

wework/src/features/workbench/runtimeTaskLifecycle/RuntimeTaskLifecycleStore.ts

@@ -39,15 +39,22 @@ const RUNTIME_TASK_LIFECYCLE_READ_METHODS = new Set<PropertyKey>([
 export class RuntimeTaskLifecycleStore {
   private readonly machines = new Map<string, RuntimeTaskMachine>()
   private readonly deviceAliases = new Map<string, string>()
+  private readonly previousRunningTaskKeys: Set<string>
   private readonly listeners = new Set<Listener>()
   private readonly unreadStorageKey: string
+  private readonly runningStorageKey: string
   private currentTaskKey: string | null = null
   private persistedUnreadSerialized: string | null = null
+  private persistedRunningSerialized: string | null = null
   private version = 0
   private snapshot = EMPTY_STORE_SNAPSHOT
 
   constructor(userId: number | string | null | undefined) {
-    this.unreadStorageKey = `wework.runtimeTaskLifecycle.${userId ?? 'anonymous'}.unread.v1`
+    const storageScope = `wework.runtimeTaskLifecycle.${userId ?? 'anonymous'}`
+    this.unreadStorageKey = `${storageScope}.unread`
+    this.runningStorageKey = `${storageScope}.running`
+    this.previousRunningTaskKeys = readStoredTaskKeys(this.runningStorageKey)
+    this.persistedRunningSerialized = serializeTaskKeys(this.previousRunningTaskKeys)
   }
 
   subscribe = (listener: Listener): (() => void) => {
@@ -259,7 +266,9 @@ export class RuntimeTaskLifecycleStore {
 
   remove(address: RuntimeTaskAddress): void {
     const canonicalAddress = this.canonicalizeAddress(address)
-    const deleted = this.machines.delete(getRuntimeTaskLifecycleKey(canonicalAddress))
+    const key = getRuntimeTaskLifecycleKey(canonicalAddress)
+    const deleted = this.machines.delete(key)
+    this.previousRunningTaskKeys.delete(key)
     if (deleted) this.publish()
   }
 
@@ -286,6 +295,8 @@ export class RuntimeTaskLifecycleStore {
       event.type === 'executor_snapshot_received' ? { ...event, address: canonicalAddress } : event
     const machine = this.ensureMachine(canonicalAddress)
     const previous = machine.getSnapshot()
+    const key = previous.key
+    const wasRunning = previous.derived.isRunning || this.previousRunningTaskKeys.has(key)
     if (
       canonicalEvent.type === 'executor_snapshot_received' &&
       previous.task &&
@@ -297,14 +308,16 @@ export class RuntimeTaskLifecycleStore {
     let changed = eventChanged
     const next = machine.getSnapshot()
     if (
-      previous.derived.isRunning &&
+      wasRunning &&
       !next.derived.isRunning &&
       !next.derived.isQueued &&
       next.goalStatus !== 'active' &&
       next.key !== this.currentTaskKey
     ) {
       changed = machine.dispatch({ type: 'marked_unread' }) || changed
     }
+    if (next.derived.isRunning) this.previousRunningTaskKeys.add(key)
+    else this.previousRunningTaskKeys.delete(key)
     if (next.derived.isRunning || next.key === this.currentTaskKey) {
       changed = machine.dispatch({ type: 'marked_read' }) || changed
     }
@@ -408,6 +421,9 @@ export class RuntimeTaskLifecycleStore {
       })
     }
     if (previousState.unread) nextMachine.dispatch({ type: 'marked_unread' })
+    if (this.previousRunningTaskKeys.delete(previousKey)) {
+      this.previousRunningTaskKeys.add(nextKey)
+    }
     this.machines.delete(previousKey)
     if (this.currentTaskKey === previousKey) this.currentTaskKey = nextKey
   }
@@ -433,26 +449,19 @@ export class RuntimeTaskLifecycleStore {
       unreadTaskKeys,
     }
     this.persistUnreadKeys(unreadTaskKeys)
+    this.persistRunningKeys()
     this.listeners.forEach(listener => listener())
   }
 
   private readUnreadKeys(): Set<string> {
-    if (typeof window === 'undefined') return new Set()
-    try {
-      const value = JSON.parse(window.localStorage.getItem(this.unreadStorageKey) ?? '[]')
-      const keys = new Set<string>(
-        Array.isArray(value) ? value.filter(item => typeof item === 'string') : []
-      )
-      this.persistedUnreadSerialized = serializeUnreadKeys(keys)
-      return keys
-    } catch {
-      return new Set()
-    }
+    const keys = readStoredTaskKeys(this.unreadStorageKey)
+    this.persistedUnreadSerialized = serializeTaskKeys(keys)
+    return keys
   }
 
   private persistUnreadKeys(keys: ReadonlySet<string>): void {
     if (typeof window === 'undefined') return
-    const serialized = serializeUnreadKeys(keys)
+    const serialized = serializeTaskKeys(keys)
     if (serialized === this.persistedUnreadSerialized) return
     try {
       window.localStorage.setItem(this.unreadStorageKey, serialized)
@@ -461,6 +470,18 @@ export class RuntimeTaskLifecycleStore {
       console.warn('Failed to persist runtime task unread state', error)
     }
   }
+
+  private persistRunningKeys(): void {
+    if (typeof window === 'undefined') return
+    const serialized = serializeTaskKeys(this.previousRunningTaskKeys)
+    if (serialized === this.persistedRunningSerialized) return
+    try {
+      window.localStorage.setItem(this.runningStorageKey, serialized)
+      this.persistedRunningSerialized = serialized
+    } catch (error) {
+      console.warn('Failed to persist runtime task running state', error)
+    }
+  }
 }
 
 export function createRuntimeTaskLifecycleOwnershipView(
@@ -570,6 +591,16 @@ function emptyRuntimeTaskSummary(address: RuntimeTaskAddress): RuntimeTaskSummar
   }
 }
 
-function serializeUnreadKeys(keys: ReadonlySet<string>): string {
+function serializeTaskKeys(keys: ReadonlySet<string>): string {
   return JSON.stringify([...keys].slice(-200))
 }
+
+function readStoredTaskKeys(storageKey: string): Set<string> {
+  if (typeof window === 'undefined') return new Set()
+  try {
+    const value = JSON.parse(window.localStorage.getItem(storageKey) ?? '[]')
+    return new Set(Array.isArray(value) ? value.filter(item => typeof item === 'string') : [])
+  } catch {
+    return new Set()
+  }
+}