@linxin666/dsh-client-ui-task-board 0.1.16 → 0.1.18

package/src/client/board/NewTaskModal.tsx

@@ -2,9 +2,12 @@
  * New-task modal: title + description + the prompt that execution will send.
  * Creates through the controller (which persists immediately).
  */
-import { useState } from 'react'
+import { useEffect, useState } from 'react'
 import type { BoardController } from '../../core/controller.ts'
-import { t } from '../locales.ts'
+import { isValidCron, nextRunAtMs } from '../../core/schedule.ts'
+import { TASK_PERMISSIONS, type TaskPermission } from '../../core/tasks.ts'
+import { t, type TaskBoardKey } from '../locales.ts'
+import { SCHEDULE_PRESETS } from '../schedule-presets.ts'
 import css from '../board.module.css'
 
 /** New-task form overlay. */
@@ -12,10 +15,39 @@ export function NewTaskModal({ controller, onClose }: { controller: BoardControl
   const [title, setTitle] = useState('')
   const [description, setDescription] = useState('')
   const [prompt, setPrompt] = useState('')
+  const [workspaceId, setWorkspaceId] = useState('')
+  const [mode, setMode] = useState('')
+  const [permission, setPermission] = useState('')
+  const [scheduleEnabled, setScheduleEnabled] = useState(false)
+  const [scheduleCron, setScheduleCron] = useState('')
+  const [scheduleError, setScheduleError] = useState<string | undefined>(undefined)
   const [error, setError] = useState<string | undefined>(undefined)
+  const [options, setOptions] = useState(controller.getSnapshot().executionOptions)
+
+  // The workspace list and preset roster arrive from the runtime after mount;
+  // follow them so the pickers never freeze on an empty snapshot.
+  useEffect(
+    () => controller.subscribe(() => setOptions(controller.getSnapshot().executionOptions)),
+    [controller],
+  )
 
   const submit = (): void => {
-    const task = controller.createTask({ title, description, prompt })
+    if (scheduleEnabled) {
+      const cron = scheduleCron.trim()
+      if (cron === '' || !isValidCron(cron)) {
+        setScheduleError(t('detail.schedule.invalid'))
+        return
+      }
+    }
+    const task = controller.createTask({
+      title,
+      description,
+      prompt,
+      workspaceId: workspaceId === '' ? undefined : workspaceId,
+      mode: mode === '' ? undefined : mode,
+      permission: permission === '' ? undefined : permission as TaskPermission,
+      schedule: scheduleEnabled ? { enabled: true, cron: scheduleCron.trim() } : undefined,
+    })
     if (task === undefined) {
       setError(t('new.required'))
       return
@@ -23,6 +55,11 @@ export function NewTaskModal({ controller, onClose }: { controller: BoardControl
     onClose()
   }
 
+  /** Next-run preview for a valid armed cron (creation-time only). */
+  const scheduleNextRun = scheduleEnabled && scheduleCron.trim() !== '' && isValidCron(scheduleCron)
+    ? nextRunAtMs(scheduleCron, Date.now())
+    : undefined
+
   return (
     <div className={css.modalBackdrop} onMouseDown={event => { if (event.target === event.currentTarget) onClose() }}>
       <form
@@ -66,6 +103,102 @@ export function NewTaskModal({ controller, onClose }: { controller: BoardControl
           />
         </label>
 
+        <label className={css.field}>
+          <span className={css.fieldLabel}>{t('new.workspace')}</span>
+          <select
+            className={css.select}
+            value={workspaceId}
+            onChange={event => { setWorkspaceId(event.target.value) }}
+          >
+            <option value="">{t('exec.workspace.recent')}</option>
+            {options.workspaces.map(workspace => (
+              <option key={workspace.workspaceId} value={workspace.workspaceId}>{workspace.title}</option>
+            ))}
+          </select>
+        </label>
+
+        <label className={css.field}>
+          <span className={css.fieldLabel}>{t('new.mode')}</span>
+          <select
+            className={css.select}
+            value={mode}
+            onChange={event => { setMode(event.target.value) }}
+          >
+            <option value="">{t('exec.mode.default')}</option>
+            {options.presets.map(preset => (
+              <option key={preset.id} value={preset.id} disabled={preset.broken !== undefined}>
+                {preset.name ?? preset.id}
+                {preset.isDefault ? t('exec.mode.defaultSuffix') : ''}
+                {preset.broken !== undefined ? t('exec.mode.brokenSuffix') : ''}
+              </option>
+            ))}
+          </select>
+        </label>
+
+        <label className={css.field}>
+          <span className={css.fieldLabel}>{t('new.permission')}</span>
+          <select
+            className={css.select}
+            value={permission}
+            onChange={event => { setPermission(event.target.value) }}
+          >
+            <option value="">{t('exec.permission.default')}</option>
+            {TASK_PERMISSIONS.map(id => (
+              <option key={id} value={id}>{t(`exec.permission.${id}` as TaskBoardKey)}</option>
+            ))}
+          </select>
+        </label>
+
+        <section className={css.detailSection}>
+          <h4>{t('detail.schedule')}</h4>
+          <label className={css.scheduleToggle}>
+            <input
+              type="checkbox"
+              checked={scheduleEnabled}
+              onChange={event => {
+                setScheduleEnabled(event.target.checked)
+                if (!event.target.checked) setScheduleError(undefined)
+              }}
+            />
+            <span>{t('detail.schedule.enable')}</span>
+          </label>
+          {scheduleEnabled && (
+            <>
+              <div className={css.scheduleRow}>
+                <input
+                  className={`${css.input} ${css.scheduleInput}${scheduleError !== undefined ? ` ${css.scheduleInputInvalid}` : ''}`}
+                  value={scheduleCron}
+                  placeholder="0 9 * * *"
+                  spellCheck={false}
+                  aria-label={t('detail.schedule.cron')}
+                  onChange={event => { setScheduleCron(event.target.value); setScheduleError(undefined) }}
+                />
+                <select
+                  className={css.schedulePreset}
+                  value=""
+                  aria-label={t('detail.schedule.presets')}
+                  onChange={event => {
+                    if (event.target.value === '') return
+                    setScheduleCron(event.target.value)
+                    setScheduleError(undefined)
+                  }}
+                >
+                  <option value="">{t('detail.schedule.presets')}…</option>
+                  {SCHEDULE_PRESETS.map(preset => (
+                    <option key={preset.cron} value={preset.cron}>{t(preset.label)}</option>
+                  ))}
+                </select>
+              </div>
+              {scheduleError !== undefined && <p className={css.formError}>{scheduleError}</p>}
+              {scheduleError === undefined && scheduleNextRun !== undefined && (
+                <p className={css.scheduleMeta}>
+                  {t('detail.schedule.nextRun')} {new Date(scheduleNextRun).toLocaleString()}
+                </p>
+              )}
+            </>
+          )}
+        </section>
+
         {error !== undefined && <p className={css.formError}>{error}</p>}
 
         <footer className={css.modalFooter}>

package/src/client/board/TaskBoard.tsx

@@ -49,7 +49,12 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
   const [filter, setFilter] = useState('')
   const [showNew, setShowNew] = useState(false)
   const selected = selectedTaskOf(snapshot)
-  const visible = snapshot.tasks.filter(task => matchesFilter(task, filter))
+  const archiveView = snapshot.archiveView
+  // Archived tasks leave the columns; the archive view shows them instead.
+  const visible = snapshot.tasks.filter(task =>
+    (archiveView ? task.archivedAt !== undefined : task.archivedAt === undefined)
+    && matchesFilter(task, filter),
+  )
   const openTask = useCallback((id: string): void => { controller.openTask(id) }, [controller])
 
   return (
@@ -64,6 +69,15 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
           onChange={event => { setFilter(event.target.value) }}
           aria-label={t('board.search')}
         />
+        <button
+          type="button"
+          className={archiveView ? css.primaryButton : css.ghostButton}
+          onClick={() => { controller.toggleArchiveView() }}
+        >
+          {archiveView
+            ? t('board.backToBoard')
+            : t('board.archiveView', { count: String(snapshot.tasks.filter(task => task.archivedAt !== undefined).length) })}
+        </button>
         <button
           type="button"
           className={css.primaryButton}
@@ -81,24 +95,39 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
       </header>
 
       <div className={css.columns}>
-        {COLUMNS.map(column => {
-          const tasks = visible.filter(task => task.status === column.status)
-          return (
-            <section key={column.status} className={css.column} data-status={column.status}>
-              <header className={css.columnHeader}>
-                <span className={css.statusDot} data-status={column.status} aria-hidden="true" />
-                <h3 className={css.columnTitle}>{t(STATUS_KEY[column.status])}</h3>
-                <span className={css.columnCount}>{tasks.length}</span>
-              </header>
-              <div className={css.cards}>
-                {tasks.map(task => (
-                  <MemoTaskCard key={task.id} task={task} onOpen={openTask} />
-                ))}
-                {tasks.length === 0 && <div className={css.columnEmpty}>{t('board.empty')}</div>}
-              </div>
-            </section>
-          )
-        })}
+        {archiveView ? (
+          <section className={css.column} data-status="archived">
+            <header className={css.columnHeader}>
+              <h3 className={css.columnTitle}>{t('board.archive')}</h3>
+              <span className={css.columnCount}>{visible.length}</span>
+            </header>
+            <div className={css.cards}>
+              {visible.map(task => (
+                <MemoTaskCard key={task.id} task={task} onOpen={openTask} />
+              ))}
+              {visible.length === 0 && <div className={css.columnEmpty}>{t('archive.empty')}</div>}
+            </div>
+          </section>
+        ) : (
+          COLUMNS.map(column => {
+            const tasks = visible.filter(task => task.status === column.status)
+            return (
+              <section key={column.status} className={css.column} data-status={column.status}>
+                <header className={css.columnHeader}>
+                  <span className={css.statusDot} data-status={column.status} aria-hidden="true" />
+                  <h3 className={css.columnTitle}>{t(STATUS_KEY[column.status])}</h3>
+                  <span className={css.columnCount}>{tasks.length}</span>
+                </header>
+                <div className={css.cards}>
+                  {tasks.map(task => (
+                    <MemoTaskCard key={task.id} task={task} onOpen={openTask} />
+                  ))}
+                  {tasks.length === 0 && <div className={css.columnEmpty}>{t('board.empty')}</div>}
+                </div>
+              </section>
+            )
+          })
+        )}
       </div>
 
       {selected !== undefined && (

package/src/client/board/TaskDetail.tsx

@@ -7,8 +7,9 @@
 import { useEffect, useState } from 'react'
 import type { BoardController } from '../../core/controller.ts'
 import { isValidCron } from '../../core/schedule.ts'
-import { MANUAL_STATUSES, type ExecutionRecord, type TaskRecord, type TaskStatus } from '../../core/tasks.ts'
+import { MANUAL_STATUSES, TASK_PERMISSIONS, type ExecutionRecord, type TaskPermission, type TaskRecord, type TaskStatus } from '../../core/tasks.ts'
 import { t, type TaskBoardKey } from '../locales.ts'
+import { SCHEDULE_PRESETS } from '../schedule-presets.ts'
 import css from '../board.module.css'
 import { ConfirmDialog } from './ConfirmDialog.tsx'
 import { formatTime } from './TaskCard.tsx'
@@ -58,13 +59,73 @@ function ExecutionRow({ execution, onOpen }: { execution: ExecutionRecord; onOpe
   )
 }
 
-/** Common scheduled-run presets (cron → locale label). */
-const SCHEDULE_PRESETS: ReadonlyArray<{ cron: string; label: TaskBoardKey }> = [
-  { cron: '0 9 * * *', label: 'detail.schedule.preset.daily9' },
-  { cron: '0 * * * *', label: 'detail.schedule.preset.hourly' },
-  { cron: '*/10 * * * *', label: 'detail.schedule.preset.tenMin' },
-  { cron: '0 9 * * 1', label: 'detail.schedule.preset.weeklyMon9' },
-]
+/** The execution-target editor: workspace / mode / permission pickers. */
+function ExecutionSettingsSection({ controller, task }: { controller: BoardController; task: TaskRecord }) {
+  const [options, setOptions] = useState(controller.getSnapshot().executionOptions)
+  useEffect(
+    () => controller.subscribe(() => setOptions(controller.getSnapshot().executionOptions)),
+    [controller],
+  )
+  const workspaceId = task.workspaceId ?? ''
+  const mode = task.mode ?? ''
+  const permission = task.permission ?? ''
+  // A pinned target may disappear from the runtime (workspace deleted,
+  // preset removed); keep it selectable as a stale row instead of silently
+  // dropping it, so the user sees exactly what the task will ask for.
+  const workspaceKnown = workspaceId === '' || options.workspaces.some(item => item.workspaceId === workspaceId)
+  const modeKnown = mode === '' || options.presets.some(item => item.id === mode)
+  return (
+    <section className={css.detailSection}>
+      <h4>{t('detail.executionSettings')}</h4>
+      <p className={css.detailText}>{t('exec.hint')}</p>
+      <label className={css.field}>
+        <span className={css.fieldLabel}>{t('new.workspace')}</span>
+        <select
+          className={css.select}
+          value={workspaceId}
+          onChange={event => { controller.updateTask(task.id, { workspaceId: event.target.value }) }}
+        >
+          <option value="">{t('exec.workspace.recent')}</option>
+          {!workspaceKnown && <option value={workspaceId}>{workspaceId}{t('exec.mode.removed')}</option>}
+          {options.workspaces.map(workspace => (
+            <option key={workspace.workspaceId} value={workspace.workspaceId}>{workspace.title}</option>
+          ))}
+        </select>
+      </label>
+      <label className={css.field}>
+        <span className={css.fieldLabel}>{t('new.mode')}</span>
+        <select
+          className={css.select}
+          value={mode}
+          onChange={event => { controller.updateTask(task.id, { mode: event.target.value }) }}
+        >
+          <option value="">{t('exec.mode.default')}</option>
+          {!modeKnown && <option value={mode}>{mode}{t('exec.mode.removed')}</option>}
+          {options.presets.map(preset => (
+            <option key={preset.id} value={preset.id} disabled={preset.broken !== undefined}>
+              {preset.name ?? preset.id}
+              {preset.isDefault ? t('exec.mode.defaultSuffix') : ''}
+              {preset.broken !== undefined ? t('exec.mode.brokenSuffix') : ''}
+            </option>
+          ))}
+        </select>
+      </label>
+      <label className={css.field}>
+        <span className={css.fieldLabel}>{t('new.permission')}</span>
+        <select
+          className={css.select}
+          value={permission}
+          onChange={event => { controller.updateTask(task.id, { permission: event.target.value === '' ? undefined : event.target.value as TaskPermission }) }}
+        >
+          <option value="">{t('exec.permission.default')}</option>
+          {TASK_PERMISSIONS.map(id => (
+            <option key={id} value={id}>{t(`exec.permission.${id}` as TaskBoardKey)}</option>
+          ))}
+        </select>
+      </label>
+    </section>
+  )
+}
 
 /** The scheduled-runs editor: enable toggle, cron input + presets, next-run info. */
 function ScheduleSection({ controller, task }: { controller: BoardController; task: TaskRecord }) {
@@ -203,6 +264,8 @@ export function TaskDetail({ controller, task }: { controller: BoardController;
             <pre className={css.promptBlock}>{current.prompt !== '' ? current.prompt : current.title}</pre>
           </section>
 
+          <ExecutionSettingsSection controller={controller} task={current} />
+
           <ScheduleSection controller={controller} task={current} />
 
           <section className={css.detailSection}>
@@ -254,6 +317,31 @@ export function TaskDetail({ controller, task }: { controller: BoardController;
           >
             {current.executions.length === 0 ? t('detail.run') : t('detail.rerun')}
           </button>
+          {current.archivedAt !== undefined ? (
+            <button
+              type="button"
+              className={css.primaryButton}
+              onClick={() => {
+                controller.restoreTask(current.id)
+                controller.closeTask()
+              }}
+            >
+              {t('detail.restore')}
+            </button>
+          ) : (
+            (current.status === 'done' || current.status === 'failed') && (
+              <button
+                type="button"
+                className={css.ghostButton}
+                onClick={() => {
+                  controller.archiveTask(current.id)
+                  controller.closeTask()
+                }}
+              >
+                {t('detail.archive')}
+              </button>
+            )
+          )}
           <button
             type="button"
             className={css.dangerButton}
@@ -263,6 +351,7 @@ export function TaskDetail({ controller, task }: { controller: BoardController;
           </button>
           <span className={css.detailMeta}>
             {t('board.created')} {formatTime(current.createdAt)}
+            {current.archivedAt !== undefined && ` · ${t('detail.archivedAt', { time: formatTime(current.archivedAt) })}`}
           </span>
         </footer>
       </div>

package/src/client/board.module.css

@@ -512,6 +512,18 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
   border-color: var(--dsw-alias-state-business-primary);
 }
 
+.select {
+  padding: 7px 10px;
+  font-size: 13px;
+  color: var(--dsw-alias-label-primary);
+  background: var(--dsw-specific-input-major);
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 8px;
+  outline: none;
+  font-family: inherit;
+  max-width: 100%;
+}
+
 .input::placeholder {
   color: var(--dsw-alias-label-tertiary);
 }
@@ -775,6 +787,7 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
 .linkButton:focus-visible,
 .search:focus-visible,
 .input:focus-visible,
+.select:focus-visible,
 .schedulePreset:focus-visible,
 .scheduleToggle input:focus-visible {
   outline: 2px solid var(--dsw-alias-state-business-primary);
@@ -790,6 +803,7 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
 .linkButton,
 .search,
 .input,
+.select,
 .schedulePreset,
 .scheduleToggle input {
   transition: background-color 120ms ease, color 120ms ease, border-color 120ms ease, outline-color 120ms ease, box-shadow 120ms ease, transform 120ms ease;
@@ -834,6 +848,7 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
 
 /* --- search box focus (border tint + themed ring above) --- */
 .search:focus,
+.select:focus,
 .schedulePreset:focus {
   border-color: var(--dsw-alias-state-business-primary);
 }
@@ -855,6 +870,7 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
   .linkButton,
   .search,
   .input,
+  .select,
   .schedulePreset,
   .scheduleToggle input {
     transition: none;

package/src/client/index.ts

@@ -9,7 +9,7 @@
  * plugin must not take the GUI down.
  */
 import type { ClientContext, SessionId, SettingsScope, SettingsScopeSpec, WorkspaceId } from '@deepseek-ai/dsh-client-runtime/client'
-import type { ConnectionHandle } from '@deepseek-ai/dsh-client-connection/client'
+import type { ConnectionHandle, PromptContentPart } from '@deepseek-ai/dsh-client-connection/client'
 import type {} from '@deepseek-ai/dsh-client-ui-slots'
 // Type-only: pulls the locale plugin's Context merge (ctx.locale) and its
 // LocaleNamespaceMap merge table.
@@ -116,12 +116,40 @@ export function apply(ctx: ClientContext): void {
     const exec = new ExecutionService({
       sessions: {
         list: sessions.list,
-        binding: id => sessions.binding(id as SessionId),
+        binding: id => {
+          const binding = sessions.binding(id as SessionId)
+          if (binding === undefined) return undefined
+          const { session } = binding
+          return {
+            session: {
+              rename: title => session.rename(title),
+              prompt: (content, mode) =>
+                session.prompt(content as PromptContentPart[], mode).then(result =>
+                  result.ok ? { ok: true as const } : { ok: false as const, error: result.error }),
+              command: line =>
+                session.command(line).then(result =>
+                  result.ok ? { ok: true as const, matched: result.value.matched } : { ok: false as const, error: result.error }),
+              getSnapshot: () => session.getSnapshot(),
+              subscribe: fn => session.subscribe(fn),
+            },
+          }
+        },
+        noteAgentPreset: (sessionId, agentPreset) => sessions.noteAgentPreset(sessionId as SessionId, agentPreset),
       },
       workspaces: {
         list: workspaces.list,
         connectWorkspace: id => workspaces.connectWorkspace(id as WorkspaceId),
       },
+      presets: {
+        select: async (sessionId, agentPreset) => {
+          try {
+            const response = await connection.api.agentPresets.select({ sessionId: sessionId as SessionId, agentPreset })
+            return response.result.ok ? { ok: true as const } : { ok: false as const, error: response.result.error }
+          } catch (error) {
+            return { ok: false as const, error }
+          }
+        },
+      },
       history: {
         loadTail: async sessionId => {
           const response = await connection.api.sessions.history({
@@ -150,6 +178,9 @@ export function apply(ctx: ClientContext): void {
     // not-yet-ready runtime; tab visibility recovery ticks immediately.
     const scheduler = new SchedulerService({
       tasks: () => controller.getSnapshot().tasks,
+      // Re-read the persisted ledger before every fire decision: a task
+      // deleted in another tab must never fire from a stale in-memory copy.
+      refresh: () => controller.reloadFromStore(),
       now: () => Date.now(),
       runTask: id => controller.runTask(id),
       applySchedule: (id, nextRunAt, lastTriggeredAt) =>
@@ -163,6 +194,44 @@ export function apply(ctx: ClientContext): void {
     scheduler.start()
 
     const disposers: Array<() => void> = []
+
+    // Execution-target option feeds: the workspace list drives the workspace
+    // picker, and the agent-preset roster drives the mode picker. Both are
+    // runtime facts (not ledger state), so the wiring pushes them into the
+    // controller on change; the preset roster is re-read after reconnects
+    // because a reconnect may serve a different deployment.
+    const pushWorkspaceOptions = (): void => {
+      const snapshot = workspaces.list.getSnapshot()
+      controller.setExecutionOptions({
+        workspaces: snapshot.items.map(item => ({
+          workspaceId: item.workspaceId,
+          title: item.title !== '' ? item.title : item.path,
+        })),
+      })
+    }
+    pushWorkspaceOptions()
+    disposers.push(workspaces.list.subscribe(pushWorkspaceOptions))
+    const pushPresetOptions = async (): Promise<void> => {
+      try {
+        const response = await connection.api.agentPresets.list({})
+        if (!response.result.ok) return
+        controller.setExecutionOptions({
+          presets: response.result.value.presets.map(preset => ({
+            id: preset.id,
+            name: preset.name,
+            description: preset.description,
+            broken: preset.broken,
+            isDefault: preset.isDefault,
+          })),
+        })
+      } catch (error) {
+        // A failed roster read leaves the previous options in place; the
+        // picker stays usable and the next reconnect retries the read.
+        console.error('[dsh-task-board] agent preset roster read failed', error)
+      }
+    }
+    void pushPresetOptions()
+    disposers.push(ctx.on('connection/reset', () => { void pushPresetOptions() }))
     try {
       disposers.push(mountSidebarEntry(controller))
       disposers.push(mountBoard(controller))

package/src/client/locales.ts

@@ -14,6 +14,10 @@ export const zh = {
   'board.search': '筛选任务…',
   'board.empty': '这个状态还没有任务',
   'board.filterAll': '全部',
+  'board.archive': '归档',
+  'board.archiveView': '归档 ({count})',
+  'board.backToBoard': '返回看板',
+  'archive.empty': '没有已归档的任务',
   'board.status': '状态',
   'board.status.backlog': '待规划',
   'board.status.todo': '待办',
@@ -41,6 +45,9 @@ export const zh = {
   'detail.run': '执行',
   'detail.rerun': '重新执行',
   'detail.delete': '删除',
+  'detail.archive': '归档',
+  'detail.restore': '恢复',
+  'detail.archivedAt': '已归档 · {time}',
   'detail.viewSession': '查看会话',
   'detail.noSession': '暂无会话',
   'detail.executionStarted': '已启动',
@@ -73,6 +80,20 @@ export const zh = {
   'detail.schedule.notScheduled': '尚未排程',
   'detail.schedule.dueSoon': '即将运行',
   'card.scheduled': '定时',
+  'new.workspace': '工作区',
+  'new.mode': '模式',
+  'new.permission': '权限',
+  'exec.workspace.recent': '最近使用（默认）',
+  'exec.mode.default': '部署默认',
+  'exec.mode.defaultSuffix': '（默认）',
+  'exec.mode.brokenSuffix': '（不可用）',
+  'exec.mode.removed': '（已移除）',
+  'exec.permission.default': '会话默认',
+  'exec.permission.read-only': '只读',
+  'exec.permission.workspace-write': '工作区可写',
+  'exec.permission.danger-full-access': '完全访问',
+  'detail.executionSettings': '执行设置',
+  'exec.hint': '执行时生效：工作区决定执行会话落在哪个工作区；模式决定会话的 agent 预设；权限经 /permission 命令应用到会话。留空则使用运行时默认。',
   // 插件设置卡片（settings.plugin.item 席位）。
   'settings.title': '任务看板',
   'settings.description': '控制看板在 agent 系统提示中的播报行为。',
@@ -106,6 +127,10 @@ export const en: Record<keyof typeof zh, string> = {
   'board.search': 'Filter tasks…',
   'board.empty': 'No tasks in this column',
   'board.filterAll': 'All',
+  'board.archive': 'Archive',
+  'board.archiveView': 'Archived ({count})',
+  'board.backToBoard': 'Back to board',
+  'archive.empty': 'No archived tasks',
   'board.status': 'Status',
   'board.status.backlog': 'Backlog',
   'board.status.todo': 'To Do',
@@ -133,6 +158,9 @@ export const en: Record<keyof typeof zh, string> = {
   'detail.run': 'Run',
   'detail.rerun': 'Run Again',
   'detail.delete': 'Delete',
+  'detail.archive': 'Archive',
+  'detail.restore': 'Restore',
+  'detail.archivedAt': 'Archived · {time}',
   'detail.viewSession': 'View Session',
   'detail.noSession': 'No session',
   'detail.executionStarted': 'Started',
@@ -165,6 +193,20 @@ export const en: Record<keyof typeof zh, string> = {
   'detail.schedule.notScheduled': 'Not scheduled yet',
   'detail.schedule.dueSoon': 'Due soon',
   'card.scheduled': 'scheduled',
+  'new.workspace': 'Workspace',
+  'new.mode': 'Mode',
+  'new.permission': 'Permission',
+  'exec.workspace.recent': 'Most recent (default)',
+  'exec.mode.default': 'Deployment default',
+  'exec.mode.defaultSuffix': ' (default)',
+  'exec.mode.brokenSuffix': ' (unavailable)',
+  'exec.mode.removed': ' (removed)',
+  'exec.permission.default': 'Session default',
+  'exec.permission.read-only': 'Read-only',
+  'exec.permission.workspace-write': 'Workspace Write',
+  'exec.permission.danger-full-access': 'Full Access',
+  'detail.executionSettings': 'Execution Settings',
+  'exec.hint': 'Applied when the task runs: the workspace decides where the execution session lands; the mode composes the session\'s agent preset; the permission is applied through the /permission command. Blank = runtime default.',
   // Plugin settings card (the `settings.plugin.item` seat).
   'settings.title': 'Task Board',
   'settings.description': 'How the board announces itself in each agent system prompt.',

package/src/client/schedule-presets.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared scheduled-run presets for the schedule editors (the new-task dialog
+ * and the task detail panel): cron expression → locale label.
+ */
+import type { TaskBoardKey } from './locales.ts'
+
+/** Common scheduled-run presets (cron → locale label). */
+export const SCHEDULE_PRESETS: ReadonlyArray<{ cron: string; label: TaskBoardKey }> = [
+  { cron: '0 9 * * *', label: 'detail.schedule.preset.daily9' },
+  { cron: '0 * * * *', label: 'detail.schedule.preset.hourly' },
+  { cron: '*/10 * * * *', label: 'detail.schedule.preset.tenMin' },
+  { cron: '0 9 * * 1', label: 'detail.schedule.preset.weeklyMon9' },
+]

package/src/client/settings-card.module.css

@@ -42,6 +42,15 @@
   outline-offset: -2px;
 }
 
+.headerStatic {
+  width: 100%;
+  border-radius: 12px;
+  align-items: center;
+  gap: 12px;
+  padding: 14px 16px;
+  display: flex;
+}
+
 .headText {
   flex-direction: column;
   flex: 1;