dsh-taskboard 0.1.2 → 0.2.0

package/src/client/controller.ts

@@ -11,6 +11,7 @@ import type { ChangeEvent, UpdateTaskBody, WorkspaceView } from '../shared/api.t
 import type { TaskLedger, TaskRecord, Urgency } from '../shared/protocol.ts'
 import { emptyLedger } from '../shared/protocol.ts'
 import type { TaskboardClient } from './api.ts'
+import type { SessionJumpResult } from './session-jump.ts'
 
 /** View filters over the ledger. */
 export interface BoardFilters {
@@ -20,12 +21,39 @@ export interface BoardFilters {
   urgencies: Urgency[]
 }
 
+/** Column sort orders. */
+export type SortBy = 'default' | 'updated' | 'urgency' | 'created'
+
+/** localStorage key for persisted view state (filters + sort). */
+const VIEW_KEY = 'dsh-taskboard-view-v1'
+
+/** Load the persisted view state (never throws; fresh on any parse error). */
+function loadView(): { workspaceId?: string; urgencies: Urgency[]; sortBy: SortBy } {
+  try {
+    const raw = localStorage.getItem(VIEW_KEY)
+    if (raw === null) return { urgencies: [], sortBy: 'default' }
+    const parsed = JSON.parse(raw) as { workspaceId?: string; urgencies?: Urgency[]; sortBy?: SortBy }
+    const sortBy = parsed.sortBy === 'updated' || parsed.sortBy === 'urgency' || parsed.sortBy === 'created' ? parsed.sortBy : 'default'
+    return {
+      workspaceId: typeof parsed.workspaceId === 'string' ? parsed.workspaceId : undefined,
+      urgencies: Array.isArray(parsed.urgencies) ? parsed.urgencies.filter(u => u === 'urgent' || u === 'normal' || u === 'relaxed') : [],
+      sortBy,
+    }
+  } catch {
+    return { urgencies: [], sortBy: 'default' }
+  }
+}
+
 /** Controller snapshot the views render. */
 export interface ControllerState {
   boardOpen: boolean
   ledger: TaskLedger
   workspaces: WorkspaceView[]
   filters: BoardFilters
+  /** Free-text search over title/id (case-insensitive). */
+  search: string
+  /** Column sort order. */
+  sortBy: SortBy
   /** Selected task id (detail view); undefined closes the detail. */
   selectedId?: string
   /** Task form modal visible (create when editingId is unset). */
@@ -38,13 +66,16 @@ export interface ControllerState {
   error?: string
 }
 
-/** Instantiate the default state. */
+/** Instantiate the default state (view state hydrated from localStorage). */
 function initialState(): ControllerState {
+  const view = loadView()
   return {
     boardOpen: false,
     ledger: emptyLedger(),
     workspaces: [],
-    filters: { urgencies: [] },
+    filters: { workspaceId: view.workspaceId, urgencies: view.urgencies },
+    search: '',
+    sortBy: view.sortBy,
     composerOpen: false,
     secondaryOpen: false,
   }
@@ -59,6 +90,7 @@ export class BoardController {
   private disposed = false
   private disposeStream: (() => void) | undefined
   private refreshInFlight: Promise<void> | undefined
+  private sessionJumper: ((sessionId: string) => Promise<SessionJumpResult>) | undefined
 
   /** @param client - the route client. */
   constructor(private readonly client: TaskboardClient) {}
@@ -137,17 +169,41 @@ export class BoardController {
   /** Toggle the board. */
   toggleBoard(): void { this.setState({ boardOpen: !this.state.boardOpen }) }
 
-  /** Set the project filter. */
+  /** Set the project filter (persisted). */
   setWorkspaceFilter(workspaceId?: string): void {
     this.setState({ filters: { ...this.state.filters, workspaceId } })
+    this.persistView()
   }
 
-  /** Toggle one urgency chip. */
+  /** Toggle one urgency chip (persisted). */
   toggleUrgency(urgency: Urgency): void {
     const set = new Set(this.state.filters.urgencies)
     if (set.has(urgency)) set.delete(urgency)
     else set.add(urgency)
     this.setState({ filters: { ...this.state.filters, urgencies: [...set] } })
+    this.persistView()
+  }
+
+  /** Set the free-text search (transient — not persisted). */
+  setSearch(search: string): void {
+    this.setState({ search })
+  }
+
+  /** Set the column sort order (persisted). */
+  setSortBy(sortBy: SortBy): void {
+    this.setState({ sortBy })
+    this.persistView()
+  }
+
+  /** Write the current view state to localStorage (best effort). */
+  private persistView(): void {
+    try {
+      localStorage.setItem(VIEW_KEY, JSON.stringify({
+        workspaceId: this.state.filters.workspaceId,
+        urgencies: this.state.filters.urgencies,
+        sortBy: this.state.sortBy,
+      }))
+    } catch { /* storage unavailable (private mode etc.) — view just won't persist */ }
   }
 
   /** Select a task (open detail). */
@@ -165,6 +221,34 @@ export class BoardController {
   /** Toggle the secondary tab. */
   toggleSecondary(): void { this.setState({ secondaryOpen: !this.state.secondaryOpen }) }
 
+  /**
+   * Install the session-jump bridge (built from the runtime sessions service
+   * by the client entry). Without it openSession reports 'unavailable'.
+   * @param jumper - the jump function from createSessionJumper.
+   */
+  installSessionJumper(jumper: (sessionId: string) => Promise<SessionJumpResult>): void {
+    this.sessionJumper = jumper
+  }
+
+  /**
+   * Jump to an execution's session (open it in the GUI). On success the board
+   * closes so the conversation shows; a deleted-or-archived session reports
+   * 'missing' for the caller to prompt about.
+   * @param sessionId - the execution's session id.
+   * @returns the jump outcome.
+   */
+  async openSession(sessionId: string): Promise<SessionJumpResult> {
+    if (this.sessionJumper === undefined) return 'unavailable'
+    let result: SessionJumpResult
+    try {
+      result = await this.sessionJumper(sessionId)
+    } catch {
+      return 'unavailable'
+    }
+    if (result === 'opened') this.closeBoard()
+    return result
+  }
+
   // ---------------------------------------------------------------- writes
   /** Create a task (composer submit); returns the new task id, undefined on failure. */
   async create(body: Parameters<TaskboardClient['create']>[0]): Promise<string | undefined> {
@@ -232,6 +316,16 @@ export class BoardController {
     }
   }
 
+  /** Cancel the running execution (stops the agent session; task returns to todo). */
+  async cancel(id: string): Promise<void> {
+    try {
+      await this.client.cancel(id)
+      await this.refresh()
+    } catch (error) {
+      this.setState({ error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+
   /** Soft-delete (agent parity) then optional purge. */
   async remove(id: string, ifVersion: number, purge: boolean): Promise<void> {
     try {
@@ -242,4 +336,69 @@ export class BoardController {
       this.setState({ error: error instanceof Error ? error.message : String(error) })
     }
   }
+
+  /** Duplicate a task into a fresh todo card (same project/urgency/prompt/execution/model). */
+  async duplicate(task: TaskRecord): Promise<void> {
+    try {
+      await this.client.create({
+        title: `${task.title}（副本）`,
+        workspaceId: task.workspaceId,
+        urgency: task.urgency,
+        description: task.description.length > 0 ? task.description : undefined,
+        prompt: task.prompt.length > 0 ? task.prompt : undefined,
+        execution: task.execution.mode === 'scheduled' && task.execution.cron !== undefined
+          ? { mode: 'scheduled', cron: task.execution.cron }
+          : { mode: 'claim' },
+        model: task.model,
+      })
+      await this.refresh()
+    } catch (error) {
+      this.setState({ error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+
+  /** Download the whole ledger as a JSON backup file. */
+  exportJson(): void {
+    const stamp = new Date()
+    const pad = (n: number) => String(n).padStart(2, '0')
+    const name = `dsh-taskboard-${stamp.getFullYear()}${pad(stamp.getMonth() + 1)}${pad(stamp.getDate())}-${pad(stamp.getHours())}${pad(stamp.getMinutes())}.json`
+    const body = JSON.stringify(this.state.ledger, null, 2)
+    this.download(name, body, 'application/json')
+  }
+
+  /** Download the task list as a CSV (BOM-prefixed for Excel + Chinese text). */
+  exportCsv(): void {
+    const esc = (v: unknown): string => {
+      const s = String(v ?? '')
+      return /[",\n\r]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s
+    }
+    const header = ['id', 'title', 'status', 'urgency', 'blocked', 'project', 'claimedBy', 'mode', 'cron', 'nextRunAt', 'model', 'createdAt', 'updatedAt', 'comments', 'executions']
+    const rows = this.state.ledger.tasks.map(t => [
+      t.id, t.title, t.status, t.urgency, t.blocked ? 'yes' : 'no', t.workspaceId,
+      t.claimedBy ?? '', t.execution.mode, t.execution.cron ?? '',
+      t.execution.nextRunAt !== undefined ? new Date(t.execution.nextRunAt).toISOString() : '',
+      t.model !== undefined ? `${t.model.provider}/${t.model.model}` : '',
+      new Date(t.createdAt).toISOString(), new Date(t.updatedAt).toISOString(),
+      t.comments.length, t.executions.length,
+    ].map(esc).join(','))
+    const stamp = new Date()
+    const pad = (n: number) => String(n).padStart(2, '0')
+    const name = `dsh-taskboard-${stamp.getFullYear()}${pad(stamp.getMonth() + 1)}${pad(stamp.getDate())}.csv`
+    this.download(name, `\uFEFF${[header.join(','), ...rows].join('\r\n')}`, 'text/csv')
+  }
+
+  /** Trigger a browser download (no-op when the DOM is unavailable). */
+  private download(filename: string, body: string, type: string): void {
+    try {
+      const blob = new Blob([body], { type })
+      const url = URL.createObjectURL(blob)
+      const a = document.createElement('a')
+      a.href = url
+      a.download = filename
+      a.click()
+      setTimeout(() => URL.revokeObjectURL(url), 5_000)
+    } catch (error) {
+      this.setState({ error: error instanceof Error ? error.message : String(error) })
+    }
+  }
 }

package/src/client/index.ts

@@ -16,6 +16,7 @@ import { BoardController } from './controller.ts'
 import { injectStyles } from './styles.ts'
 import { mountSidebarEntry } from './sidebar-entry.ts'
 import { mountBoard } from './board-mount.tsx'
+import { createSessionJumper, type SessionsServiceFace, type WorkspacesServiceFace } from './session-jump.ts'
 
 /** Client plugin name. */
 export const name = 'dsh-taskboard/client'
@@ -65,6 +66,15 @@ export function apply(ctx: ClientContextFace): void {
       }
     }
 
+    // Session navigation for execution rows: resolved LAZILY on every jump —
+    // apply may run before the runtime provides the services, and a captured
+    // undefined would permanently disable the jump. On a platform without
+    // them the jump degrades to an 'unavailable' notice instead of failing.
+    controller.installSessionJumper(createSessionJumper({
+      getSessions: () => ctx.get?.('sessions') as SessionsServiceFace | undefined,
+      getWorkspaces: () => ctx.get?.('workspaces') as WorkspacesServiceFace | undefined,
+    }))
+
     controller.start()
     const disposers: Array<() => void> = []
     try {

package/src/client/session-jump.ts

@@ -0,0 +1,93 @@
+/**
+ * Session jump: resolve an execution's session against the runtime's live
+ * session list and open it in the GUI. The runtime's `sessions` service owns
+ * the list mirror (`list.getSnapshot().byId`) and staging (`open`); the
+ * `workspaces` service carries the registry-global archive set.
+ *
+ * Outcomes are split so the UI can prompt precisely:
+ * - `opened`     — staged and opened; the board closes over it.
+ * - `archived`   — in the list but archived (hidden from the sidebar; its log
+ *                  survives, so it is distinguishable from deletion).
+ * - `missing`    — absent from the live list: deleted.
+ * - `unavailable`— runtime session services absent (service timing / errors).
+ *
+ * Service resolution is deliberately LAZY (per click): plugin apply may run
+ * before the runtime provides `sessions`, and a once-captured undefined would
+ * permanently disable the jump. When the id misses, the list mirror may also
+ * simply lag (reconnect re-pull, late mount): one `refresh()` is awaited and
+ * the lookup retried before deciding.
+ *
+ * @module dsh-taskboard/client/session-jump
+ */
+
+/** Outcome of one jump attempt. */
+export type SessionJumpResult =
+  | 'opened'
+  | 'archived'
+  | 'missing'
+  | 'unavailable'
+
+/** Narrow face of the runtime `sessions` service this module needs. */
+export interface SessionsServiceFace {
+  /** Select a listed session as current (the window opens with it). */
+  open(id: string): void
+  /** Re-pull the session list baseline (mirror catch-up). */
+  refresh(): Promise<void>
+  /** Live session list snapshot. */
+  list: {
+    getSnapshot(): {
+      byId: Record<string, unknown>
+    }
+  }
+}
+
+/** Narrow face of the runtime `workspaces` service this module needs. */
+export interface WorkspacesServiceFace {
+  /** Workspace list snapshot (carries the archive set). */
+  list: {
+    getSnapshot(): {
+      archivedSessionIds: readonly string[]
+    }
+  }
+}
+
+/** Lazy per-click service resolution (services may appear after apply). */
+export interface SessionServiceAccess {
+  /** The runtime sessions service, when currently provided. */
+  getSessions(): SessionsServiceFace | undefined
+  /** The runtime workspaces service, when currently provided (optional). */
+  getWorkspaces(): WorkspacesServiceFace | undefined
+}
+
+/**
+ * Build the jump function the controller installs.
+ * @param access - lazy service accessors, consulted on every jump.
+ * @returns the jump function: `(sessionId) => Promise<SessionJumpResult>`.
+ */
+export function createSessionJumper(access: SessionServiceAccess): (sessionId: string) => Promise<SessionJumpResult> {
+  const lookup = (sessions: SessionsServiceFace, workspaces: WorkspacesServiceFace | undefined, sessionId: string): 'openable' | 'archived' | 'absent' => {
+    const list = sessions.list.getSnapshot()
+    if (list.byId[sessionId] === undefined) return 'absent'
+    const archived = workspaces?.list.getSnapshot().archivedSessionIds.includes(sessionId) ?? false
+    return archived ? 'archived' : 'openable'
+  }
+  return async (sessionId: string): Promise<SessionJumpResult> => {
+    const sessions = access.getSessions()
+    if (sessions === undefined) return 'unavailable'
+    try {
+      let state = lookup(sessions, access.getWorkspaces(), sessionId)
+      if (state === 'absent') {
+        // Only the absent case can be a lagging mirror (reconnect re-pull,
+        // late mount); archived is a definitive verdict. One refresh, re-check.
+        try { await sessions.refresh() } catch { /* keep the pre-refresh verdict */ }
+        state = lookup(sessions, access.getWorkspaces(), sessionId)
+      }
+      if (state === 'archived') return 'archived'
+      if (state === 'absent') return 'missing'
+      sessions.open(sessionId)
+      return 'opened'
+    } catch {
+      return 'unavailable'
+    }
+  }
+}

package/src/client/sidebar-entry.ts

@@ -59,11 +59,106 @@ function createEntry(controller: BoardController): HTMLButtonElement {
   entry.dataset.dshAtbEntry = ''
   entry.className = 'dsh-atb-entry'
   entry.setAttribute('aria-label', 'Agent 任务看板')
-  entry.innerHTML = `<span class="dsh-atb-entry-icon">${ICON}</span><span class="dsh-atb-entry-label">任务看板</span>`
+  entry.innerHTML = `<span class="dsh-atb-entry-icon">${ICON}</span><span class="dsh-atb-entry-label">任务看板</span><span class="dsh-atb-entry-stats"></span>`
   entry.addEventListener('click', () => { controller.toggleBoard() })
   return entry
 }
 
+/**
+ * Live status counts shown at the right of the entry row:
+ * `[todo, in_progress, in_review]` (trashed tasks excluded).
+ */
+function entryStats(controller: BoardController): [number, number, number] {
+  let todo = 0
+  let inProgress = 0
+  let inReview = 0
+  for (const task of controller.getSnapshot().ledger.tasks) {
+    if (task.trashedAt !== undefined) continue
+    if (task.status === 'todo') todo++
+    else if (task.status === 'in_progress') inProgress++
+    else if (task.status === 'in_review') inReview++
+  }
+  return [todo, inProgress, inReview]
+}
+
+/**
+ * Set one rolling-number slot. Unchanged values no-op; changes animate the
+ * old value out and the new value in with a vertical scroll (up when the
+ * count grows, down when it shrinks). Plain DOM, no React.
+ */
+function setRollValue(slot: HTMLElement, value: number): void {
+  const text = String(value)
+  if (slot.dataset.value === text) return
+  const previous = slot.dataset.value
+  slot.dataset.value = text
+  slot.style.minWidth = `${text.length}ch`
+  // First render (no previous value): plain text, no animation.
+  if (previous === undefined) {
+    slot.textContent = text
+    return
+  }
+  // Finalize any in-flight animation before starting the next one.
+  if (slot.dataset.busy === '1') {
+    slot.dataset.busy = ''
+    slot.dataset.anim = ''
+  }
+  const oldEl = document.createElement('span')
+  oldEl.className = 'dsh-atb-rn'
+  oldEl.textContent = previous
+  const newEl = document.createElement('span')
+  newEl.className = 'dsh-atb-rn dsh-atb-rn-next'
+  newEl.textContent = text
+  slot.replaceChildren(oldEl, newEl)
+  // Grow → the strip scrolls up (new enters from below); shrink → down.
+  slot.dataset.dir = value > Number(previous) ? 'up' : 'down'
+  slot.dataset.busy = '1'
+  requestAnimationFrame(() => { slot.dataset.anim = '1' })
+  const finish = (): void => {
+    if (slot.dataset.busy !== '1') return
+    slot.dataset.busy = ''
+    slot.dataset.anim = ''
+    slot.textContent = slot.dataset.value ?? ''
+  }
+  slot.addEventListener('transitionend', finish, { once: true })
+  // Fallback when transitionend never fires (hidden tab, reduced motion).
+  setTimeout(finish, 400)
+}
+
+/**
+ * Wire the stats strip into the entry: builds the three slots and keeps them
+ * (plus the tooltip) in sync with every controller emit.
+ * @returns the update function (also called once immediately).
+ */
+function wireStats(entry: HTMLButtonElement, controller: BoardController): () => void {
+  const stats = entry.querySelector<HTMLElement>('.dsh-atb-entry-stats')
+  if (stats === null) return () => {}
+  // Slot order = [todo, in_progress, in_review]; each slot carries its status
+  // in data-stat so the stylesheet colors the digits (see .dsh-atb-roll).
+  const statKeys = ['todo', 'in_progress', 'in_review'] as const
+  const slots: HTMLElement[] = []
+  for (let i = 0; i < 3; i++) {
+    if (i > 0) {
+      const sep = document.createElement('span')
+      sep.className = 'dsh-atb-entry-sep'
+      sep.textContent = '|'
+      stats.append(sep)
+    }
+    const slot = document.createElement('span')
+    slot.className = 'dsh-atb-roll'
+    slot.dataset.stat = statKeys[i]
+    stats.append(slot)
+    slots.push(slot)
+  }
+  const update = (): void => {
+    const [todo, inProgress, inReview] = entryStats(controller)
+    setRollValue(slots[0]!, todo)
+    setRollValue(slots[1]!, inProgress)
+    setRollValue(slots[2]!, inReview)
+    stats.title = `待办 ${todo} ｜ 进行中 ${inProgress} ｜ 待验收 ${inReview}（待办|进行中|待验收）`
+  }
+  return update
+}
+
 /** Re-insert the entry after the New Session row (before the browser region). */
 function placeEntry(root: HTMLElement, entry: HTMLButtonElement): boolean {
   const button = newSessionButton(root)
@@ -146,9 +241,11 @@ export function mountSidebarEntry(controller: BoardController): () => void {
   // alone; the timer costs one cheap contains-check per tick once placed).
   const retry = setInterval(() => { tryPlace() }, 2_000)
 
+  const syncStats = wireStats(entry, controller)
   const syncActive = () => {
     if (controller.getSnapshot().boardOpen) entry.dataset.active = 'true'
     else delete entry.dataset.active
+    syncStats()
   }
   const unsubscribe = controller.subscribe(syncActive)
   syncActive()

package/src/client/styles.ts

@@ -10,7 +10,7 @@
 /** The stylesheet text. */
 export const STYLES = `
 .dsh-atb-entry {
-  display: flex; align-items: center; gap: 8px;
+  display: flex; align-items: center; gap: 8px; position: relative;
   width: calc(100% - 8px); margin: 2px 4px; padding: 6px 10px;
   border: none; border-radius: 8px; background: transparent;
   color: var(--dsw-text-secondary, inherit); font: inherit; font-size: 13px;
@@ -19,6 +19,35 @@ export const STYLES = `
 .dsh-atb-entry:hover { background: var(--dsw-hover, rgba(128,128,128,.12)); color: var(--dsw-text-primary, inherit); }
 .dsh-atb-entry[data-active="true"] { background: var(--dsw-active, rgba(128,128,128,.18)); color: var(--dsw-text-primary, inherit); font-weight: 500; }
 .dsh-atb-entry svg { flex: none; }
+/* Status strip on the entry row's right: todo|in_progress|in_review counts. */
+.dsh-atb-entry-stats {
+  margin-left: auto; display: inline-flex; align-items: center; gap: 3px;
+  font-size: 11px; line-height: 1; color: var(--dsw-text-secondary, gray);
+  font-variant-numeric: tabular-nums; white-space: nowrap; cursor: help;
+}
+.dsh-atb-entry-sep { opacity: .5; }
+/* Each rolling count wears its status color (todo blue | in_progress orange |
+   in_review purple); the separators stay in the strip's neutral gray. */
+.dsh-atb-roll[data-stat="todo"] { color: #3e63dd; }
+.dsh-atb-roll[data-stat="in_progress"] { color: #d9822b; }
+.dsh-atb-roll[data-stat="in_review"] { color: #8e4ec6; }
+/* One rolling number: fixed one-line window, overflow hidden. */
+.dsh-atb-roll {
+  position: relative; display: inline-block; overflow: hidden;
+  height: 12px; min-width: 1ch; text-align: center; vertical-align: middle;
+}
+.dsh-atb-rn { display: block; height: 12px; line-height: 12px; text-align: center; }
+/* The incoming value sits just outside the window (below for up-scroll). */
+.dsh-atb-rn-next { position: absolute; left: 0; right: 0; top: 100%; }
+.dsh-atb-roll[data-dir="down"] .dsh-atb-rn-next { top: auto; bottom: 100%; }
+.dsh-atb-roll .dsh-atb-rn { transition: transform .3s cubic-bezier(.25, .1, .25, 1); }
+.dsh-atb-roll[data-anim="1"][data-dir="up"] .dsh-atb-rn { transform: translateY(-100%); }
+.dsh-atb-roll[data-anim="1"][data-dir="down"] .dsh-atb-rn { transform: translateY(100%); }
+@media (prefers-reduced-motion: reduce) {
+  .dsh-atb-roll .dsh-atb-rn { transition: none; }
+}
+.dsh-atb-search { width: 130px; }
+.dsh-atb-badge[data-kind="stale"] { background: rgba(217,130,43,.15); color: #d9822b; }
 
 html[data-dsh-atb-active] [data-pane="conversation"] > *:not([data-dsh-atb-view]) { display: none !important; }
 .dsh-atb-view { display: none; }
@@ -28,6 +57,16 @@ html[data-dsh-atb-active] .dsh-atb-view { display: flex; flex-direction: column;
 .dsh-atb-toolbar { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; }
 .dsh-atb-title { font-size: 15px; font-weight: 600; margin: 0; }
 .dsh-atb-count { font-size: 12px; color: var(--dsw-text-secondary, gray); }
+.dsh-atb-ver {
+  font-size: 11px; color: var(--dsw-text-secondary, gray);
+  font-variant-numeric: tabular-nums; white-space: nowrap; cursor: pointer;
+  text-decoration: none;
+  padding: 1px 9px; border-radius: 999px;
+  background: var(--dsw-bg-inset, rgba(128,128,128,.1));
+  border: 1px solid var(--dsw-border, rgba(128,128,128,.22));
+  transition: border-color .12s ease, color .12s ease;
+}
+.dsh-atb-ver:hover { border-color: var(--dsw-border-strong, rgba(128,128,128,.6)); color: inherit; }
 .dsh-atb-spacer { flex: 1; }
 .dsh-atb-select, .dsh-atb-input {
   font: inherit; font-size: 12.5px; padding: 5px 8px; border-radius: 7px;
@@ -48,6 +87,16 @@ html[data-dsh-atb-active] .dsh-atb-view { display: flex; flex-direction: column;
 .dsh-atb-dot[data-urgency="urgent"] { background: #e5484d; }
 .dsh-atb-dot[data-urgency="normal"] { background: #8e4ec6; }
 .dsh-atb-dot[data-urgency="relaxed"] { background: #3e63dd; }
+/* Status dots (column heads): one fixed color per lifecycle status, matching
+   the detail pane's status pills. Canceled/archived share the resting gray;
+   trashed (pending purge) keeps the red of the 待清除 badge. */
+.dsh-atb-dot[data-status="backlog"] { background: #8a8f98; }
+.dsh-atb-dot[data-status="todo"] { background: #3e63dd; }
+.dsh-atb-dot[data-status="in_progress"] { background: #d9822b; }
+.dsh-atb-dot[data-status="in_review"] { background: #8e4ec6; }
+.dsh-atb-dot[data-status="done"] { background: #2ea043; }
+.dsh-atb-dot[data-status="canceled"], .dsh-atb-dot[data-status="archived"] { background: #8a8f98; }
+.dsh-atb-dot[data-status="trashed"] { background: #e5484d; }
 
 .dsh-atb-btn {
   font: inherit; font-size: 12.5px; padding: 5px 11px; border-radius: 7px; cursor: pointer;
@@ -178,6 +227,7 @@ html[data-dsh-atb-active] .dsh-atb-view { display: flex; flex-direction: column;
   transition: filter .12s ease;
 }
 .dsh-atb-detail-run:hover { filter: brightness(1.1); }
+.dsh-atb-detail-run[data-danger="true"] { background: rgba(229,72,77,.92); }
 .dsh-atb-movebtns { display: flex; gap: 6px; flex-wrap: wrap; }
 .dsh-atb-movebtn {
   font: inherit; font-size: 12px; padding: 4px 11px; border-radius: 999px; cursor: pointer;
@@ -256,7 +306,11 @@ html[data-dsh-atb-active] .dsh-atb-view { display: flex; flex-direction: column;
 .dsh-atb-exec-outcome[data-outcome="running"] { background: rgba(217,130,43,.15); color: #d9822b; }
 .dsh-atb-exec-outcome[data-outcome="cancelled"] { background: rgba(128,128,128,.15); color: var(--dsw-text-secondary, gray); }
 .dsh-atb-exec-time { font-size: 11px; color: var(--dsw-text-secondary, gray); }
-.dsh-atb-exec-session { font-size: 11px; color: var(--dsw-text-secondary, gray); }
+.dsh-atb-exec-session {
+  font: inherit; font-size: 11px; color: var(--dsw-text-secondary, gray);
+  background: none; border: none; padding: 0; cursor: pointer;
+}
+.dsh-atb-exec-session:hover { color: var(--dsw-alias-brand-primary, inherit); text-decoration: underline dotted; }
 .dsh-atb-exec-error { flex-basis: 100%; font-size: 11px; color: #e5484d; word-break: break-all; }
 
 .dsh-atb-dangerzone {