dsh-taskboard 0.1.1 → 0.2.0

package/src/client/board/TaskDetail.tsx

@@ -11,7 +11,8 @@ import { useState, type ReactNode } from 'react'
 import type { BoardController } from '../controller.ts'
 import type { TaskRecord } from '../../shared/protocol.ts'
 import { canTransition } from '../../shared/protocol.ts'
-import { fmtTime } from './TaskBoard.tsx'
+import { useAlert } from './AlertModal.tsx'
+import { fmtTime, isStaleClaim } from './TaskBoard.tsx'
 
 /** Statuses a user may move this task to, per the state machine. */
 function moveTargets(task: TaskRecord): TaskRecord['status'][] {
@@ -27,10 +28,10 @@ const STATUS_LABEL: Record<string, string> = { ...MOVE_LABEL }
 const URGENCY_LABEL: Record<string, string> = { urgent: '紧急', normal: '一般', relaxed: '不急' }
 const OUTCOME_LABEL: Record<string, string> = { running: '执行中', succeeded: '成功', failed: '失败', cancelled: '已取消' }
 
-/** Compact session-id display. */
+/** Compact session-id display (execution sessions carry the taskboard infix). */
 function shortId(id: string | undefined): string {
   if (id === undefined) return ''
-  return id.replace(/^session-/, '').slice(0, 8)
+  return id.replace(/^session-(taskboard-)?/, '').slice(0, 8)
 }
 
 /** Execution duration between start and end. */
@@ -51,13 +52,28 @@ function Chip({ icon, children, tone }: { icon?: string; children: ReactNode; to
  * The detail view.
  * @param task - the task record.
  * @param controller - the controller.
+ * @param now - current epoch ms (stale-claim highlight).
  */
-export function TaskDetail({ task, controller }: { task: TaskRecord; controller: BoardController }) {
+export function TaskDetail({ task, controller, now }: { task: TaskRecord; controller: BoardController; now?: number }) {
   const [comment, setComment] = useState('')
   const [confirmDone, setConfirmDone] = useState(false)
   const [confirmPurge, setConfirmPurge] = useState(false)
+  const [confirmCancel, setConfirmCancel] = useState(false)
+  const { alert: showAlert, el: alertEl } = useAlert()
   const ws = controller.getSnapshot().workspaces.find(w => w.id === task.workspaceId)
   const canRun = task.status !== 'in_progress' && task.status !== 'done' && task.status !== 'archived'
+  const runningExecution = task.executions.find(e => e.outcome === 'running')
+  const holder = task.status === 'in_progress' ? task.claimedBy : undefined
+  const stale = now !== undefined && isStaleClaim(task, now)
+
+  /** Jump to an execution's session; prompt precisely when it cannot open. */
+  const jumpToSession = (sessionId: string): void => {
+    void controller.openSession(sessionId).then(result => {
+      if (result === 'missing') showAlert(`该会话已被删除（${shortId(sessionId)}），无法打开`)
+      else if (result === 'archived') showAlert(`该会话已归档（${shortId(sessionId)}），已从会话列表隐藏`)
+      else if (result === 'unavailable') showAlert(`会话导航不可用，会话 ID：${sessionId}`)
+    })
+  }
 
   return (
     <div className="dsh-atb-detail" data-urgency={task.urgency}>
@@ -75,6 +91,11 @@ export function TaskDetail({ task, controller }: { task: TaskRecord; controller:
               <Chip icon="⏰">{task.execution.cron} · 下次 {fmtTime(task.execution.nextRunAt)}</Chip>
             )}
             {task.blocked && <Chip icon="⛔" tone="urgent">受阻</Chip>}
+            {holder !== undefined && (
+              <Chip icon={stale ? '⏱' : '🔑'} tone={stale ? 'urgent' : undefined}>
+                {stale ? '认领超时 · ' : '由 '}{shortId(holder)} 持有
+              </Chip>
+            )}
             {task.trashedAt !== undefined && <Chip icon="🗑" tone="urgent">已删除待清除</Chip>}
             <Chip>v{task.version}</Chip>
           </div>
@@ -84,6 +105,43 @@ export function TaskDetail({ task, controller }: { task: TaskRecord; controller:
         </div>
         <div className="dsh-atb-detail-topbtns">
           <button type="button" className="dsh-atb-detail-edit" onClick={() => controller.openEditor(task.id)}>✎ 编辑</button>
+          <button
+            type="button"
+            className="dsh-atb-detail-edit"
+            title="复制此任务的全部配置为一张新卡（待办列）"
+            onClick={() => void controller.duplicate(task)}
+          >
+            ⧉ 复制
+          </button>
+          {canRun && (
+            <button
+              type="button"
+              className="dsh-atb-detail-run"
+              title={task.model !== undefined ? `新会话执行（${task.model.model}）` : '新会话执行（默认模型）'}
+              onClick={() => void controller.run(task.id)}
+            >
+              ▶ 立即执行
+            </button>
+          )}
+          {runningExecution !== undefined && (confirmCancel
+            ? (
+              <span className="dsh-atb-confirm">
+                <span className="dsh-atb-confirm-label">停止该执行会话？</span>
+                <button type="button" className="dsh-atb-btn" data-danger="true" onClick={() => { void controller.cancel(task.id); setConfirmCancel(false) }}>停止</button>
+                <button type="button" className="dsh-atb-btn" onClick={() => setConfirmCancel(false)}>取消</button>
+              </span>
+            )
+            : (
+              <button
+                type="button"
+                className="dsh-atb-detail-run"
+                data-danger="true"
+                title={`停止执行会话 ${runningExecution.sessionId ?? ''}（任务回到待办）`}
+                onClick={() => setConfirmCancel(true)}
+              >
+                ■ 停止执行
+              </button>
+            ))}
           <button type="button" className="dsh-atb-detail-close" aria-label="关闭" onClick={() => controller.select(undefined)}>✕</button>
         </div>
       </div>
@@ -103,11 +161,6 @@ export function TaskDetail({ task, controller }: { task: TaskRecord; controller:
       )}
 
       <div className="dsh-atb-detail-actions">
-        {canRun && (
-          <button type="button" className="dsh-atb-runbtn" onClick={() => void controller.run(task.id)}>
-            ▶ 执行 · 新会话{task.model !== undefined ? `（${task.model.model}）` : '（默认模型）'}
-          </button>
-        )}
         <div className="dsh-atb-movebtns">
           {moveTargets(task).map(to => to === 'done'
             ? (confirmDone
@@ -118,15 +171,26 @@ export function TaskDetail({ task, controller }: { task: TaskRecord; controller:
                       <button type="button" className="dsh-atb-btn" onClick={() => setConfirmDone(false)}>取消</button>
                     </span>
                   )
-                : <button key={to} type="button" className="dsh-atb-movebtn" data-to={to} onClick={() => setConfirmDone(true)}>✓ {MOVE_LABEL[to]}</button>)
+                : <button key={to} type="button" className="dsh-atb-movebtn" data-to={to} onClick={() => setConfirmDone(true)}>移至→{MOVE_LABEL[to]}</button>)
             : (
                 <button key={to} type="button" className="dsh-atb-movebtn" data-to={to} onClick={() => void controller.move(task.id, task.version, to)}>
-                  {MOVE_LABEL[to]}
+                  移至→{MOVE_LABEL[to]}
                 </button>
               ))}
           <button type="button" className="dsh-atb-movebtn" data-to="blocked" onClick={() => void controller.toggleBlocked(task)}>
             {task.blocked ? '✓ 解除受阻' : '⛔ 标记受阻'}
           </button>
+          {holder !== undefined && (
+            <button
+              type="button"
+              className="dsh-atb-movebtn"
+              data-to="release"
+              title={`释放 ${holder} 的认领：任务回到待办（持有会话可能仍在工作，确认它已停止后再释放）`}
+              onClick={() => void controller.move(task.id, task.version, 'todo')}
+            >
+              🔓 释放认领
+            </button>
+          )}
         </div>
       </div>
 
@@ -176,15 +240,28 @@ export function TaskDetail({ task, controller }: { task: TaskRecord; controller:
 
       {task.executions.length > 0 && (
         <div className="dsh-atb-section">
-          <h4>执行记录<span className="dsh-atb-count2">{task.executions.length}</span></h4>
+          <h4>执行记录<span className="dsh-atb-count2">{task.executions.length}</span>
+            {task.executionsPruned !== undefined && task.executionsPruned > 0 && (
+              <span className="dsh-atb-count2" title={`更早的 ${task.executionsPruned} 条执行记录已按保留上限清理`}>+{task.executionsPruned} 已清理</span>
+            )}
+          </h4>
           <div className="dsh-atb-execlist">
-            {task.executions.map(e => (
+            {[...task.executions].reverse().map(e => (
               <div key={e.id} className="dsh-atb-exec-row">
                 <span className="dsh-atb-exec-dot" data-outcome={e.outcome} />
                 <span className="dsh-atb-exec-trigger">{e.trigger === 'manual' ? '手动' : '定时'}</span>
                 <span className="dsh-atb-exec-outcome" data-outcome={e.outcome}>{OUTCOME_LABEL[e.outcome] ?? e.outcome}</span>
                 <span className="dsh-atb-exec-time">{fmtTime(e.startedAt)}{e.endedAt !== undefined && ` · ${duration(e.startedAt, e.endedAt)}`}</span>
-                {e.sessionId !== undefined && <span className="dsh-atb-exec-session" title={e.sessionId}>🤖 {shortId(e.sessionId)}</span>}
+                {e.sessionId !== undefined && (
+                  <button
+                    type="button"
+                    className="dsh-atb-exec-session"
+                    title={`点击打开该执行会话：${e.sessionId}`}
+                    onClick={() => jumpToSession(e.sessionId!)}
+                  >
+                    🤖 {shortId(e.sessionId)} ↗
+                  </button>
+                )}
                 {e.error !== undefined && <span className="dsh-atb-exec-error" title={e.error}>{e.error.slice(0, 80)}{e.error.length > 80 ? '…' : ''}</span>}
               </div>
             ))}
@@ -205,6 +282,8 @@ export function TaskDetail({ task, controller }: { task: TaskRecord; controller:
                 )
               : <button type="button" className="dsh-atb-btn" data-danger="true" onClick={() => setConfirmPurge(true)}>🔥 物理清除（需确认）</button>)}
       </div>
+
+      {alertEl}
     </div>
   )
 }

package/src/client/board/TaskFormModal.tsx

@@ -94,6 +94,9 @@ export function TaskFormModal({ controller, task }: { controller: BoardControlle
   const cronBad = mode === 'scheduled' && (cronMatch === null || nextRun === null)
   const valid = title.trim().length > 0 && workspaceId !== '' && !cronBad
 
+  // A task already in progress cannot be run again (host rejects it).
+  const runBlocked = editing && task.status === 'in_progress'
+
   const submit = (): void => {
     if (!valid) return
     const picked = model !== '' ? (JSON.parse(model) as { provider: string; model: string }) : undefined
@@ -121,6 +124,39 @@ export function TaskFormModal({ controller, task }: { controller: BoardControlle
     }
   }
 
+  /** Save the form, then immediately trigger a manual run of the task. */
+  const submitAndRun = (): void => {
+    if (!valid || runBlocked) return
+    const picked = model !== '' ? (JSON.parse(model) as { provider: string; model: string }) : undefined
+    if (editing) {
+      void (async () => {
+        const saved = await controller.update(task.id, task.version, {
+          title,
+          description,
+          prompt,
+          urgency,
+          workspaceId,
+          execution: mode === 'scheduled' ? { mode, cron: cron.trim() } : { mode },
+          model: picked ?? null,
+        })
+        if (saved) await controller.run(task.id)
+      })()
+    } else {
+      void (async () => {
+        const id = await controller.create({
+          title,
+          workspaceId,
+          urgency,
+          description: description.length > 0 ? description : undefined,
+          prompt: prompt.length > 0 ? prompt : undefined,
+          execution: mode === 'scheduled' ? { mode, cron: cron.trim() } : { mode },
+          model: picked,
+        })
+        if (id !== undefined) await controller.run(id)
+      })()
+    }
+  }
+
   const hint = !valid
     ? (title.trim().length === 0 ? '请填写标题' : workspaceId === '' ? '请选择项目' : 'Cron 表达式无效（分 时 日 月 周）')
     : mode === 'scheduled' && nextRun !== null
@@ -186,7 +222,7 @@ export function TaskFormModal({ controller, task }: { controller: BoardControlle
           </Field>
 
           <Field label={editing ? '执行 Prompt' : '执行 Prompt（可选，默认 = 标题+描述）'} full>
-            <textarea value={prompt} onChange={e => setPrompt(e.target.value)} placeholder="发给执行会话的完整指令" />
+            <textarea value={prompt} onChange={e => setPrompt(e.target.value)} placeholder={'发给执行会话的完整指令。支持模板变量：{{lastExecution}}（上次执行结果）、{{lastComments}}（最近 3 条评论）'} />
           </Field>
 
           <Field label="执行方式" full>
@@ -233,6 +269,15 @@ export function TaskFormModal({ controller, task }: { controller: BoardControlle
           <span className="dsh-atb-modal-hint" data-tone={valid ? undefined : 'bad'}>{hint}</span>
           <span className="dsh-atb-modal-footbtns">
             <button type="button" className="dsh-atb-btn" onClick={() => controller.closeForm()}>取消</button>
+            <button
+              type="button"
+              className="dsh-atb-btn"
+              disabled={!valid || runBlocked}
+              title={runBlocked ? '任务正在执行中，不能重复发起' : '保存后立即发起执行（新会话）'}
+              onClick={submitAndRun}
+            >
+              ⚡ 立即执行
+            </button>
             <button type="button" className="dsh-atb-btn" data-primary="true" disabled={!valid} onClick={submit}>
               {editing ? '保存修改' : '创建任务'}
             </button>
@@ -247,6 +292,7 @@ export function TaskFormModal({ controller, task }: { controller: BoardControlle
 interface TaskRecordLike {
   id: string
   version: number
+  status?: string
   title: string
   description: string
   prompt: string

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,26 +221,58 @@ 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). */
-  async create(body: Parameters<TaskboardClient['create']>[0]): Promise<void> {
+  /** Create a task (composer submit); returns the new task id, undefined on failure. */
+  async create(body: Parameters<TaskboardClient['create']>[0]): Promise<string | undefined> {
     try {
-      await this.client.create(body)
+      const summary = await this.client.create(body)
       this.setState({ composerOpen: false, error: undefined })
       await this.refresh()
+      return summary.id
     } catch (error) {
       this.setState({ error: error instanceof Error ? error.message : String(error) })
+      return undefined
     }
   }
 
   /** Edit task fields (form modal submit; the GUI is the owner surface). */
-  async update(id: string, ifVersion: number, body: Omit<UpdateTaskBody, 'ifVersion'>): Promise<void> {
+  async update(id: string, ifVersion: number, body: Omit<UpdateTaskBody, 'ifVersion'>): Promise<boolean> {
     try {
       await this.client.update(id, { ifVersion, ...body })
       this.setState({ composerOpen: false, editingId: undefined, error: undefined })
       await this.refresh()
+      return true
     } catch (error) {
       this.setState({ error: error instanceof Error ? error.message : String(error) })
+      return false
     }
   }
 
@@ -228,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 {
@@ -238,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'
+    }
+  }
+}