dsh-taskboard 0.6.6 → 0.7.0

package/src/host/assets.ts

@@ -0,0 +1,120 @@
+/** Durable, content-addressed image attachments for task descriptions/comments. */
+import { createHash } from 'node:crypto'
+import { mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import type { StorageQueue } from './storage-queue.ts'
+
+export const MAX_ASSET_BYTES = 5 * 1024 * 1024
+export const MAX_ASSET_STORE_BYTES = 200 * 1024 * 1024
+export const ORPHAN_GRACE_MS = 24 * 60 * 60 * 1000
+
+export type ImageKind = { extension: 'png' | 'jpg' | 'gif' | 'webp'; mime: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp' }
+export type StoredAsset = ImageKind & { id: string; name: string; size: number; url: string }
+
+const ASSET_NAME_RE = /^([a-f0-9]{64})\.(png|jpg|gif|webp)$/
+
+/** Detect supported images from magic bytes; request MIME and filenames are not trusted. */
+export function detectImage(bytes: Uint8Array): ImageKind | undefined {
+  if (bytes.length >= 8 && bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47
+    && bytes[4] === 0x0d && bytes[5] === 0x0a && bytes[6] === 0x1a && bytes[7] === 0x0a) {
+    return { extension: 'png', mime: 'image/png' }
+  }
+  if (bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) {
+    return { extension: 'jpg', mime: 'image/jpeg' }
+  }
+  if (bytes.length >= 6) {
+    const head = Buffer.from(bytes.subarray(0, 6)).toString('ascii')
+    if (head === 'GIF87a' || head === 'GIF89a') return { extension: 'gif', mime: 'image/gif' }
+  }
+  if (bytes.length >= 12 && Buffer.from(bytes.subarray(0, 4)).toString('ascii') === 'RIFF'
+    && Buffer.from(bytes.subarray(8, 12)).toString('ascii') === 'WEBP') {
+    return { extension: 'webp', mime: 'image/webp' }
+  }
+  return undefined
+}
+
+/** Files live outside the ledger so state/SSE/tool payloads only carry short Markdown URLs. */
+export class AssetStore {
+  private queue: Promise<unknown> = Promise.resolve()
+  private root: string
+
+  constructor(root: string, private readonly now: () => number = () => Date.now(), private readonly storageQueue?: StorageQueue) { this.root = root }
+
+  /** Current absolute attachment-directory path. */
+  location(): string { return this.root }
+
+  /** Switch reads and future writes after the coordinator copied the directory. */
+  setLocation(root: string): void { this.root = root }
+
+  async put(bytes: Uint8Array, declaredMime?: string): Promise<StoredAsset> {
+    const run = () => this.putSerial(bytes, declaredMime)
+    if (this.storageQueue !== undefined) return this.storageQueue.run(run)
+    return (this.queue = this.queue.then(run, run)) as Promise<StoredAsset>
+  }
+
+  private async putSerial(bytes: Uint8Array, declaredMime?: string): Promise<StoredAsset> {
+    if (bytes.length === 0 || bytes.length > MAX_ASSET_BYTES) {
+      throw new Error(`image must be 1..${MAX_ASSET_BYTES} bytes`)
+    }
+    const kind = detectImage(bytes)
+    if (kind === undefined) throw new Error('unsupported image; use PNG, JPEG, GIF, or WebP')
+    if (declaredMime !== undefined && declaredMime.toLowerCase() !== kind.mime) {
+      throw new Error(`image content does not match ${declaredMime}`)
+    }
+    const id = createHash('sha256').update(bytes).digest('hex')
+    const name = `${id}.${kind.extension}`
+    await mkdir(this.root, { recursive: true })
+    try {
+      const current = await stat(join(this.root, name))
+      if (current.isFile()) return { id, name, size: current.size, url: `/dsh-taskboard/assets/${name}`, ...kind }
+    } catch { /* new content */ }
+
+    let total = 0
+    for (const entry of await readdir(this.root, { withFileTypes: true })) {
+      if (!entry.isFile() || !ASSET_NAME_RE.test(entry.name)) continue
+      try { total += (await stat(join(this.root, entry.name))).size } catch { /* concurrent cleanup */ }
+    }
+    if (total + bytes.length > MAX_ASSET_STORE_BYTES) throw new Error('image store quota exceeded')
+    try {
+      await writeFile(join(this.root, name), bytes, { flag: 'wx' })
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error
+    }
+    return { id, name, size: bytes.length, url: `/dsh-taskboard/assets/${name}`, ...kind }
+  }
+
+  async read(name: string): Promise<{ bytes: Buffer; mime: ImageKind['mime'] } | undefined> {
+    const run = async (): Promise<{ bytes: Buffer; mime: ImageKind['mime'] } | undefined> => {
+    const match = ASSET_NAME_RE.exec(name)
+    if (match === null) return undefined
+    const mime = match[2] === 'png' ? 'image/png'
+      : match[2] === 'jpg' ? 'image/jpeg'
+        : match[2] === 'gif' ? 'image/gif' : 'image/webp'
+    try {
+      return { bytes: await readFile(join(this.root, name)), mime }
+    } catch { return undefined }
+    }
+    return this.storageQueue === undefined ? run() : this.storageQueue.run(run)
+  }
+
+  /** Remove abandoned draft uploads after a grace period; referenced files always survive. */
+  async cleanup(referencedContent: string): Promise<number> {
+    const run = async (): Promise<number> => {
+    let entries
+    try { entries = await readdir(this.root, { withFileTypes: true }) } catch { return 0 }
+    let removed = 0
+    for (const entry of entries) {
+      if (!entry.isFile() || !ASSET_NAME_RE.test(entry.name) || referencedContent.includes(entry.name)) continue
+      const path = join(this.root, entry.name)
+      try {
+        const info = await stat(path)
+        if (this.now() - info.mtimeMs < ORPHAN_GRACE_MS) continue
+        await rm(path, { force: true })
+        removed += 1
+      } catch { /* best effort */ }
+    }
+    return removed
+    }
+    return this.storageQueue === undefined ? run() : this.storageQueue.run(run)
+  }
+}

package/src/host/execution.ts

@@ -72,7 +72,7 @@ export interface ExecutionWorkspaceFace {
 
 /** Narrow event-bus face for settlement listening. */
 export interface EventsFace {
-  onSessionEvent(listener: (sessionId: string, event: { type: string; data?: unknown }, sessionMeta?: { header?: { cwd?: string } }) => void): () => void
+  onSessionEvent(listener: (sessionId: string, event: { type: string; data?: unknown }, sessionMeta?: { header?: { cwd?: string } }) => void | Promise<void>): () => void
 }
 
 /** Everything the execution service needs. */
@@ -293,6 +293,8 @@ export class ExecutionService {
                 task.comments.push({
                   id: newCommentId(),
                   body: normalizeBody(`[系统] 执行失败：${message.slice(0, 300)}；任务已退回待办。`),
+                  systemKey: 'sys.execFailed',
+                  systemParams: { error: message.slice(0, 300) },
                   version: 1,
                   createdAt: this.deps.now(),
                 })
@@ -598,6 +600,7 @@ export class ExecutionService {
               body: normalizeBody(commented
                 ? '[系统] 执行会话已结束并留有评论，但未移至待验收；系统自动移入待验收。'
                 : '[系统] 执行会话已结束，但未按协议交接（无评论、未移至待验收）；系统自动移入待验收，请审查后退回或验收。'),
+              systemKey: commented ? 'sys.endedWithComment' : 'sys.endedNoHandoff',
               version: 1,
               createdAt: now,
             })

package/src/host/locale.ts

@@ -0,0 +1,44 @@
+/**
+ * Host-side locale reading for the few user-facing HOST log lines (the
+ * gitignore suggestion). Everything else the user sees is localized by the
+ * GUI (client i18n dictionaries), and host-written ledger comments carry a
+ * `systemKey` that the GUI localizes at render — so this module is only for
+ * the raw `console.*` lines the host emits itself.
+ *
+ * Source: the DSH locale plugin persists the explicit language choice as
+ * `locale.preference` in `$DSH_HOME/settings.yaml` (loopback pages) and
+ * exposes it through the settings service. When the preference is absent the
+ * browser delegates, which the host cannot see — so we fall back to `en`,
+ * matching the client's own fallback (zh only when something asked for it).
+ *
+ * @module dsh-taskboard/host/locale
+ */
+import type { Context } from '@deepseek-ai/cordis'
+
+/** The two locales the taskboard ships. */
+export type HostLocale = 'zh' | 'en'
+
+/** Narrow settings-service face this module consumes (stringly-typed soft access). */
+interface SettingsFace {
+  get?: (ns: string) => unknown
+}
+
+/** The DSH locale settings section (`preference` carries the explicit choice). */
+interface LocaleSettings {
+  preference?: unknown
+}
+
+/**
+ * Read the active GUI locale as a host-side hint. Absent / malformed settings
+ * (or no settings service in scope) fall back to `en` and never throw — a
+ * cosmetic log line must not break route boot.
+ */
+export function activeHostLocale(ctx: Context): HostLocale {
+  try {
+    const settings = ctx.get('settings') as SettingsFace | undefined
+    const locale = settings?.get?.('locale') as LocaleSettings | undefined
+    return locale?.preference === 'zh' ? 'zh' : 'en'
+  } catch {
+    return 'en'
+  }
+}

package/src/host/routes.ts

@@ -1,3 +1,4 @@
+import { archiveTaskSessions } from './archive-sessions.ts'
 /**
  * /dsh-taskboard routes on the shared DSH webserver: a JSON API for the
  * GUI's human operations (create/update/move/comment/delete — actor `user`,
@@ -40,12 +41,16 @@ import {
   type TaskLedger,
   type TaskModel,
   type TaskRecord,
+  type SystemCommentRow,
 } from '../shared/protocol.ts'
 import { WORKTREE_DIR, worktreePathOf, type GitFace } from './git.ts'
 import { removeMirror, repoMainPath } from './isolation.ts'
 import { createRepoScanner, type RepoScanner } from './repos.ts'
+import { activeHostLocale } from './locale.ts'
 import type { CatalogModelItem, CatalogPresetItem, MergeRepoResult, TaskTemplate } from '../shared/api.ts'
 import type { TemplateStore } from './templates.ts'
+import { MAX_ASSET_BYTES, type AssetStore } from './assets.ts'
+import type { StorageCoordinator } from './storage.ts'
 import { ROUTE_PREFIX, SSE_PATH, type ApiFail, type ApiResult } from '../shared/api.ts'
 import type { TaskStore } from './store.ts'
 import { ERR, ToolError } from './tools.ts'
@@ -61,6 +66,7 @@ const MAX_BODY_BYTES = 5 * 1024 * 1024
 const TASK_DIFF_RE = new RegExp(`^${ROUTE_PREFIX}/tasks/([^/]+)/diff$`)
 const TASK_RE = new RegExp(`^${ROUTE_PREFIX}/tasks/([^/]+)$`)
 const TASK_ACTION_RE = new RegExp(`^${ROUTE_PREFIX}/tasks/([^/]+)/([\\w-]+)$`)
+const ASSET_RE = new RegExp(`^${ROUTE_PREFIX}/assets/([a-f0-9]{64}\\.(?:png|jpg|gif|webp))$`)
 
 /** How long a workspace git-detection result stays cached (fail-soft). */
 const GIT_DETECT_TTL_MS = 60_000
@@ -88,6 +94,12 @@ export interface TaskboardRoutesOptions {
   scanner?: RepoScanner
   /** Task-template store (0.4.0); absent → 501 on template actions. */
   templates?: TemplateStore
+  /** Durable image attachment store (0.7.0); absent → attachment routes unavailable. */
+  assets?: AssetStore
+  /** Configurable data-directory coordinator (0.7.0). */
+  storage?: StorageCoordinator
+  /** Initial storage/ledger readiness barrier. */
+  ready?: () => Promise<void>
   /** Prompt completions face (0.5.5; dynamically discovers skills & commands). */
   promptCompletions?: () => Promise<{
     skills?: Array<{ name: string; description?: string }>
@@ -189,6 +201,19 @@ async function readBody(req: IncomingMessage): Promise<Record<string, unknown> |
   }
 }
 
+/** Read one bounded binary upload without ever buffering beyond the file cap. */
+async function readBytes(req: IncomingMessage, limit: number): Promise<Buffer> {
+  const chunks: Buffer[] = []
+  let total = 0
+  for await (const chunk of req) {
+    const bytes = chunk as Buffer
+    total += bytes.length
+    if (total > limit) throw new Error('body too large')
+    chunks.push(bytes)
+  }
+  return Buffer.concat(chunks)
+}
+
 /** String field accessor (null when absent/not a string). */
 function str(body: Record<string, unknown>, key: string): string | null {
   const v = body[key]
@@ -316,10 +341,15 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
     } catch { /* fail-soft → false */ }
     // gitignore 建议 (plan §3.2): suggest (never write) ignoring our
     // worktree directory, once per workspace per host run. Root repos only.
+    // The line is localized from the DSH locale preference (see host/locale.ts).
     if (rootRepo && !gitHinted.has(path)) {
       gitHinted.add(path)
       if (await gitignoreMissing(path)) {
-        console.info(`[dsh-taskboard] 建议在 ${path}/.gitignore 加入一行 ${WORKTREE_DIR}/ 以隐藏任务 worktree 目录（不会自动修改）`)
+        const file = `${path}/.gitignore`
+        const hint = activeHostLocale(ctx) === 'zh'
+          ? `建议在 ${file} 加入一行 ${WORKTREE_DIR}/ 以隐藏任务 worktree 目录（不会自动修改）`
+          : `suggests adding one line to ${file}: ${WORKTREE_DIR}/ to hide the task worktree directory (no automatic edits)`
+        console.info(`[dsh-taskboard] ${hint}`)
       }
     }
     // The nested scan always runs: repoCount needs it even when the root
@@ -370,9 +400,28 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
 
       // ---------------------------------------------------------------- GET
       if (req.method === 'GET') {
+        if (pathname === `${ROUTE_PREFIX}/storage`) {
+          if (options.storage === undefined) { res.writeHead(501); res.end(); return }
+          json(res, { ok: true, value: await options.storage.status() })
+          return
+        }
+        await options.ready?.()
+        const assetMatch = pathname.match(ASSET_RE)
+        if (assetMatch !== null) {
+          const asset = await options.assets?.read(assetMatch[1]!)
+          if (asset === undefined) { res.writeHead(404); res.end(); return }
+          res.writeHead(200, {
+            'content-type': asset.mime,
+            'content-length': asset.bytes.length,
+            'cache-control': 'public, max-age=31536000, immutable',
+            'x-content-type-options': 'nosniff',
+          })
+          res.end(asset.bytes)
+          return
+        }
         if (pathname === `${ROUTE_PREFIX}/state`) {
           await store.load()
-          json(res, { ok: true, value: store.snapshot() })
+          json(res, { ok: true, value: { ...store.snapshot(), capabilities: { archiveSessions: typeof workspaces.archiveSession === 'function' } } })
           return
         }
         if (pathname === `${ROUTE_PREFIX}/workspaces`) {
@@ -519,6 +568,34 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
         res.end()
         return
       }
+      // Content-addressed image upload. The custom header makes this a
+      // non-simple cross-origin request, preserving the JSON routes' CSRF fence.
+      if (pathname === `${ROUTE_PREFIX}/assets`) {
+        await options.ready?.()
+        if (options.assets === undefined) {
+          const f = fail('invalid_input', 'image attachments unavailable')
+          json(res, f.res, 501)
+          return
+        }
+        if (req.headers['x-dsh-taskboard-upload'] !== '1') {
+          const f = fail('forbidden', 'missing upload header')
+          json(res, f.res, 403)
+          return
+        }
+        const declaredMime = String(req.headers['content-type'] ?? '').split(';', 1)[0]!.trim().toLowerCase()
+        try {
+          const bytes = await readBytes(req, MAX_ASSET_BYTES)
+          await options.assets.cleanup(JSON.stringify(store.snapshot()))
+          const asset = await options.assets.put(bytes, declaredMime)
+          json(res, { ok: true, value: asset }, 201)
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error)
+          const status = message.includes('1..') ? 413 : message.includes('quota') ? 507 : 400
+          const f = fail('invalid_input', message)
+          json(res, f.res, status)
+        }
+        return
+      }
       // CSRF fence: cross-site simple requests cannot set application/json.
       const contentType = req.headers['content-type'] ?? ''
       if (!contentType.toLowerCase().startsWith('application/json')) {
@@ -540,6 +617,29 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
         return
       }
 
+      // Storage location is bootstrap metadata outside the ledger. Keep it on
+      // separate routes so JSON imports and whole-ledger replacement cannot
+      // redirect host filesystem writes.
+      if (pathname === `${ROUTE_PREFIX}/storage/check` || pathname === `${ROUTE_PREFIX}/storage/migrate`) {
+        if (options.storage === undefined) {
+          const f = fail('invalid_input', 'storage configuration unavailable')
+          json(res, f.res, 501)
+          return
+        }
+        try {
+          const directory = str(body, 'directory') ?? ''
+          const value = pathname.endsWith('/check')
+            ? await options.storage.check(directory)
+            : await options.storage.migrate(directory)
+          json(res, { ok: true, value })
+        } catch (error) {
+          const f = fail('invalid_input', error instanceof Error ? error.message : String(error))
+          json(res, f.res, f.status)
+        }
+        return
+      }
+      await options.ready?.()
+
       // ------------------------------------------------- POST /tasks (create)
       if (pathname === `${ROUTE_PREFIX}/tasks`) {
         try {
@@ -615,6 +715,12 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
         try {
           const task = store.get(id)
           if (task === undefined) throw new Error('Error: not_found: no such task')
+          if (action === 'archive-sessions') {
+            if (task.trashedAt !== undefined || task.status !== 'archived') throw new Error('Error: invalid_transition: only archived live tasks can retry session archiving')
+            const result = await archiveTaskSessions(task, workspaces.archiveSession)
+            json(res, { ok: true, value: result })
+            return
+          }
           if (action === 'update') {
             const ifVersion = num(body, 'ifVersion')
             if (ifVersion === undefined || ifVersion === null) throw new Error('Error: version_conflict: ifVersion required')
@@ -678,13 +784,16 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
           if (action === 'move') {
             const ifVersion = num(body, 'ifVersion')
             const status = str(body, 'status') ?? ''
+            const archiveSessions = body.archiveSessions === true
             if (ifVersion === undefined || ifVersion === null) throw new Error('Error: version_conflict: ifVersion required')
             const to = asStatus(status)
             let next: TaskRecord | undefined
+            let beforeTask: TaskRecord | undefined
             await store.mutate('task-moved', ledger => {
               const { index, task } = liveTaskAt(ledger, id)
               if (ifVersion !== task.version) throw new Error(`Error: version_conflict: stale version ${ifVersion} (current ${task.version})`)
               if (!canTransition(task.status, to)) throw new Error(`Error: invalid_transition: illegal transition ${task.status} → ${to}`)
+              beforeTask = task
               next = structuredClone(task)
               next.status = to
               next.version = task.version + 1
@@ -696,7 +805,10 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
               ledger.tasks[index] = next
               return [next]
             })
-            json(res, { ok: true, value: summarize(next!) })
+            const sessionArchive = to === 'archived' && archiveSessions
+              ? await archiveTaskSessions(beforeTask ?? next!, workspaces.archiveSession)
+              : undefined
+            json(res, { ok: true, value: { ...summarize(next!), ...(sessionArchive !== undefined ? { sessionArchive } : {}) } })
             return
           }
           if (action === 'reject') {
@@ -909,11 +1021,21 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
             }
             // R1: the git merges above are slow — re-find the FRESH task inside
             // the mutation so a concurrent comment is never overwritten.
-            const pushComment = (body: string): Promise<void> =>
+            const pushComment = (body: string, system?: { key: string; params?: Record<string, string>; rows?: SystemCommentRow[] }): Promise<void> =>
               store.mutate('comment-added', ledger => {
                 const { index, task: fresh } = liveTaskAt(ledger, id)
                 const next = structuredClone(fresh)
-                next.comments.push({ id: newCommentId(), body: normalizeBody(body), version: 1, createdAt: options.now() })
+                next.comments.push({
+                  id: newCommentId(),
+                  body: normalizeBody(body),
+                  ...(system !== undefined ? {
+                    systemKey: system.key,
+                    ...(system.params !== undefined ? { systemParams: system.params } : {}),
+                    ...(system.rows !== undefined ? { systemRows: system.rows } : {}),
+                  } : {}),
+                  version: 1,
+                  createdAt: options.now(),
+                })
                 next.version = fresh.version + 1
                 next.updatedAt = options.now()
                 ledger.tasks[index] = next
@@ -930,7 +1052,7 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
               if (root.outcome === 'failed') {
                 throw new Error(`Error: invalid_input: ${root.error ?? '合并失败'}`)
               }
-              await pushComment(`[系统] 分支 ${root.branch} 已合并到主工作区（--no-ff）。`)
+              await pushComment(`[系统] 分支 ${root.branch} 已合并到主工作区（--no-ff）。`, { key: 'sys.mergeSingle', params: { branch: root.branch } })
               json(res, { ok: true, value: { merged: true, branch: root.branch } })
               return
             }
@@ -942,7 +1064,10 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
                 ? `${labelOf(r.repo)} ✓ 已合并`
                 : r.outcome === 'noop' ? `${labelOf(r.repo)} ⟲ 无新提交` : `${labelOf(r.repo)} ✗ ${(r.error ?? '合并失败').slice(0, 150)}`)
               .join('；')
-            await pushComment(`[系统] 分支已按仓库合并（--no-ff）：${summary}`)
+            await pushComment(`[系统] 分支已按仓库合并（--no-ff）：${summary}`, {
+              key: 'sys.mergeMulti',
+              rows: results.map(r => ({ repo: r.repo, outcome: r.outcome, ...(r.error !== undefined ? { error: r.error.slice(0, 150) } : {}) })),
+            })
             json(res, {
               ok: true,
               value: {

package/src/host/scheduler.ts

@@ -136,6 +136,8 @@ export class SchedulerService {
         task.comments.push({
           id: newCommentId(),
           body: normalizeBody(`[系统] 定时表达式 ${deadCron} 在 4 年内没有可触发时间，已停用定时；请修正 cron 后重新开启。`),
+          systemKey: 'sys.cronDead',
+          systemParams: { cron: deadCron },
           version: 1,
           createdAt: now,
         })

package/src/host/session-sync.ts

@@ -213,7 +213,7 @@ export class ExternalSessionSyncService {
 
   constructor(private readonly deps: SessionSyncDeps) {
     this.unsubscribe = deps.events.onSessionEvent((sessionId, event, sessionMeta) => {
-      void this.handleSessionEvent(sessionId, event, sessionMeta)
+      return this.handleSessionEvent(sessionId, event, sessionMeta)
     })
 
     const interval = deps.scanIntervalMs ?? DEFAULT_SCAN_INTERVAL_MS
@@ -628,6 +628,8 @@ export class ExternalSessionSyncService {
           task.comments.push({
             id: newCommentId(),
             body: normalizeBody(`[系统] 会话执行异常：${errorMessage.slice(0, 300)}；任务已退回待办。`),
+            systemKey: 'sys.sessionError',
+            systemParams: { error: errorMessage.slice(0, 300) },
             version: 1,
             createdAt: now,
           })
@@ -639,6 +641,7 @@ export class ExternalSessionSyncService {
           task.comments.push({
             id: newCommentId(),
             body: normalizeBody('[系统] 会话执行完毕，已自动进入待验收。'),
+            systemKey: 'sys.sessionDone',
             version: 1,
             createdAt: now,
           })

package/src/host/storage-queue.ts

@@ -0,0 +1,10 @@
+/** One process-wide serial queue shared by all taskboard persistence. */
+export class StorageQueue {
+  private tail: Promise<unknown> = Promise.resolve()
+
+  run<T>(operation: () => Promise<T>): Promise<T> {
+    const result = this.tail.then(operation, operation)
+    this.tail = result.then(() => undefined, () => undefined)
+    return result
+  }
+}