@linxin666/dsh-client-ui-task-board 0.3.20 → 0.3.22

package/src/client/board/TaskBoard.tsx

@@ -5,7 +5,7 @@
  */
 import { memo, useCallback, useEffect, useState } from 'react'
 import { selectedTaskOf, type BoardController } from '../../core/controller.ts'
-import { COLUMNS, canMoveManually, type TaskRecord } from '../../core/tasks.ts'
+import { COLUMNS, canMoveManually, collectKnownTags, tagTone, type TaskRecord } from '../../core/tasks.ts'
 import { t } from '../locales.ts'
 import css from '../board.module.css'
 import { NewTaskModal } from './NewTaskModal.tsx'
@@ -13,15 +13,27 @@ import { STATUS_KEY } from './status-key.ts'
 import { TaskCard } from './TaskCard.tsx'
 import { TaskDetail } from './TaskDetail.tsx'
 
-/** Case-insensitive title/description/freeze-snapshot match. */
+/** Case-insensitive title/description/tag/freeze-snapshot match. */
 export function matchesFilter(task: TaskRecord, filter: string): boolean {
   if (filter.trim() === '') return true
   const needle = filter.trim().toLowerCase()
-  const haystacks = [task.title, task.description]
+  const haystacks = [task.title, task.description, ...(task.tags ?? []).map(tag => tag.name)]
   if (task.freeze !== undefined) haystacks.push(task.freeze.goal, task.freeze.progress, task.freeze.next)
   return haystacks.some(text => text.toLowerCase().includes(needle))
 }
 
+/**
+ * Whether a task carries every selected label (issue #1521). Multi-select is
+ * conjunctive: adding a label narrows the board instead of widening it, which
+ * is the only reading that keeps "工作" selected from dragging unrelated cards
+ * back in when a second label is added.
+ */
+export function matchesTagFilter(task: TaskRecord, selected: readonly string[]): boolean {
+  if (selected.length === 0) return true
+  const names = new Set((task.tags ?? []).map(tag => tag.name))
+  return selected.every(name => names.has(name))
+}
+
 /**
  * Memoized per-card adapter: with a stable `onOpen` from the board and an
  * immutable task record (only the changed card gets a new object ref), a card
@@ -41,14 +53,24 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
     [controller],
   )
   const [filter, setFilter] = useState('')
+  const [tagFilter, setTagFilter] = useState<string[]>([])
   const [showNew, setShowNew] = useState(false)
   const selected = selectedTaskOf(snapshot)
   const archiveView = snapshot.archiveView
+  // Every label in use across the ledger (board and archive alike), so the
+  // filter never loses an option just because its task was archived.
+  const knownTags = collectKnownTags(snapshot.tasks)
   // 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),
+    && matchesFilter(task, filter)
+    && matchesTagFilter(task, tagFilter),
   )
+  const toggleTag = useCallback((name: string): void => {
+    setTagFilter(current => current.includes(name)
+      ? current.filter(entry => entry !== name)
+      : [...current, name])
+  }, [])
   const openTask = useCallback((id: string): void => { controller.openTask(id) }, [controller])
 
   return (
@@ -100,6 +122,35 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
         </button>
       </header>
 
+      {!archiveView && knownTags.length > 0 && (
+        <div className={css.tagFilter} data-dsh-part="tag-filter">
+          <span className={css.tagFilterLabel}>{t('board.tagFilter')}</span>
+          {knownTags.map(tag => {
+            const active = tagFilter.includes(tag.name)
+            return (
+              <button
+                key={tag.name}
+                type="button"
+                className={css.tagChip}
+                data-dsh-part="tag-chip"
+                data-tag-tone={tagTone(tag.name)}
+                data-active={active ? 'true' : undefined}
+                aria-pressed={active}
+                title={tag.promptPrefix === undefined ? tag.name : tag.promptPrefix}
+                onClick={() => { toggleTag(tag.name) }}
+              >
+                {tag.name}
+              </button>
+            )
+          })}
+          {tagFilter.length > 0 && (
+            <button type="button" className={css.linkButton} onClick={() => { setTagFilter([]) }}>
+              {t('board.tagFilterClear')}
+            </button>
+          )}
+        </div>
+      )}
+
       {snapshot.transportError !== undefined && (
         <div className={css.formError}>
           {t('board.hostError', { error: snapshot.transportError })}{' '}
@@ -120,7 +171,9 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
               {visible.map(task => (
                 <MemoTaskCard key={task.id} task={task} pending={snapshot.pendingTaskIds.includes(task.id)} timeZone={snapshot.host?.scheduler.timeZone} onOpen={openTask} />
               ))}
-              {visible.length === 0 && <div className={css.columnEmpty}>{t('archive.empty')}</div>}
+              {visible.length === 0 && (
+                <div className={css.columnEmpty}>{tagFilter.length > 0 ? t('board.tagEmpty') : t('archive.empty')}</div>
+              )}
             </div>
           </section>
         ) : (
@@ -156,7 +209,9 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
                   {tasks.map(task => (
                     <MemoTaskCard key={task.id} task={task} pending={snapshot.pendingTaskIds.includes(task.id)} timeZone={snapshot.host?.scheduler.timeZone} onOpen={openTask} />
                   ))}
-                  {tasks.length === 0 && <div className={css.columnEmpty}>{t('board.empty')}</div>}
+                  {tasks.length === 0 && (
+                    <div className={css.columnEmpty}>{tagFilter.length > 0 ? t('board.tagEmpty') : t('board.empty')}</div>
+                  )}
                 </div>
               </section>
             )

package/src/client/board/TaskCard.tsx

@@ -9,7 +9,7 @@
  */
 import { memo } from 'react'
 import type { TaskRecord } from '../../core/tasks.ts'
-import { executionLabel } from '../../core/tasks.ts'
+import { executionLabel, tagTone } from '../../core/tasks.ts'
 import { t } from '../locales.ts'
 import css from '../board.module.css'
 
@@ -59,6 +59,22 @@ function TaskCardInner({ task, pending, timeZone, onClick }: { task: TaskRecord;
       title={task.description !== '' ? task.description : task.title}
     >
       <span className={css.cardTitle}>{task.title}</span>
+      {task.tags !== undefined && task.tags.length > 0 && (
+        <span className={css.cardTags}>
+          {task.tags.map(tag => (
+            <span
+              key={tag.name}
+              className={css.cardTag}
+              data-tag-tone={tagTone(tag.name)}
+              data-dsh-part="tag-badge"
+              data-tag-hint={tag.promptPrefix === undefined ? undefined : tag.promptPrefix}
+              title={tag.promptPrefix === undefined ? tag.name : tag.promptPrefix}
+            >
+              {tag.name}
+            </span>
+          ))}
+        </span>
+      )}
       {task.description !== '' && <span className={css.cardExcerpt}>{task.description}</span>}
       <span className={css.cardMeta}>
         <span className={css.cardTime}>{t('board.updated')} {formatTime(task.updatedAt)}</span>

package/src/client/board/TaskDetail.tsx

@@ -347,8 +347,10 @@ export function TaskDetail({ controller, task }: { controller: BoardController;
               </p>
               <p className={css.detailText}><strong>{t('detail.handover.references')}</strong></p>
               <ul className={css.executionList}>
-                {current.handover.references.map(reference => (
-                  <li key={reference} className={css.executionRow}><code>{reference}</code></li>
+                {current.handover.references.map((reference, index) => (
+                  // References are free text from the freeze block, so the same
+                  // string can appear twice; the index keeps the key unique (#1492).
+                  <li key={`${reference}-${index}`} className={css.executionRow}><code>{reference}</code></li>
                 ))}
               </ul>
               <p className={css.detailMeta}>{t('detail.handover.bundledAt', { time: formatHostTimestamp(current.handover.bundledAt, timeZone) })}</p>

package/src/client/board/TaskForm.tsx

@@ -5,9 +5,13 @@
  * are controlled components.
  */
 import type { ReactNode } from 'react'
+import { TAG_NAME_MAX_LENGTH, TAG_PROMPT_MAX_LENGTH, TASK_TAG_LIMIT, type TaskTag } from '../../core/tasks.ts'
 import { t } from '../locales.ts'
 import css from '../board.module.css'
 
+/** DOM id shared by the tag-name inputs and their datalist (one board at a time). */
+const TAG_NAME_LIST_ID = 'dsh-task-board-tag-names'
+
 /** Modal overlay: closes on backdrop press, submits through the form. */
 export function ModalShell({
   ariaLabel,
@@ -109,3 +113,91 @@ export function TaskContentFields({
     </>
   )
 }
+
+/**
+ * Task labels (issue #1521): one row per label holding the badge name and an
+ * optional execution hint. The name inputs offer the labels already used on the
+ * board through a datalist, and picking one adopts its hint when the row has
+ * none — so a business line is defined once and reused by every later task.
+ */
+export function TaskTagFields({
+  tags,
+  knownTags,
+  onChange,
+}: {
+  tags: TaskTag[]
+  /** Labels already carried elsewhere on the board. */
+  knownTags: TaskTag[]
+  onChange: (tags: TaskTag[]) => void
+}) {
+  const update = (index: number, patch: Partial<TaskTag>): void => {
+    onChange(tags.map((tag, position) => (position === index ? { ...tag, ...patch } : tag)))
+  }
+
+  return (
+    <div className={css.field}>
+      <span className={css.fieldLabel}>{t('new.tags')}</span>
+      <span className={css.fieldHint}>{t('new.tagsHint')}</span>
+      {tags.map((tag, index) => (
+        <div className={css.tagRow} key={index}>
+          <input
+            className={css.input}
+            list={TAG_NAME_LIST_ID}
+            value={tag.name}
+            maxLength={TAG_NAME_MAX_LENGTH}
+            placeholder={t('new.tagNamePlaceholder')}
+            aria-label={t('new.tagName')}
+            onChange={(event) => {
+              const name = event.target.value
+              const known = knownTags.find(candidate => candidate.name === name)
+              const adoptsHint = known?.promptPrefix !== undefined && (tag.promptPrefix ?? '').trim() === ''
+              update(index, adoptsHint ? { name, promptPrefix: known.promptPrefix } : { name })
+            }}
+          />
+          <input
+            className={css.input}
+            value={tag.promptPrefix ?? ''}
+            maxLength={TAG_PROMPT_MAX_LENGTH}
+            placeholder={t('new.tagPromptPlaceholder')}
+            aria-label={t('new.tagPrompt')}
+            onChange={event => { update(index, { promptPrefix: event.target.value }) }}
+          />
+          <button
+            type="button"
+            className={css.ghostButton}
+            aria-label={t('new.tagRemove', { name: tag.name })}
+            onClick={() => { onChange(tags.filter((_, position) => position !== index)) }}
+          >
+            ×
+          </button>
+        </div>
+      ))}
+      <datalist id={TAG_NAME_LIST_ID}>
+        {knownTags.map(tag => <option key={tag.name} value={tag.name} />)}
+      </datalist>
+      <button
+        type="button"
+        className={css.ghostButton + ' ' + css.tagAddButton}
+        disabled={tags.length >= TASK_TAG_LIMIT}
+        onClick={() => { onChange([...tags, { name: '' }]) }}
+      >
+        + {t('new.tagAdd')}
+      </button>
+    </div>
+  )
+}
+
+/**
+ * Drop blank rows and trim what survives, so the wire always carries a valid
+ * tag list (the protocol rejects a list with a blank name or an empty array).
+ */
+export function cleanTags(tags: readonly TaskTag[]): TaskTag[] {
+  const cleaned: TaskTag[] = []
+  for (const tag of tags) {
+    const name = tag.name.trim()
+    if (name === '') continue
+    const promptPrefix = tag.promptPrefix?.trim()
+    cleaned.push(promptPrefix === undefined || promptPrefix === '' ? { name } : { name, promptPrefix })
+  }
+  return cleaned
+}

package/src/client/board.module.css

@@ -1121,3 +1121,122 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
     animation: none;
   }
 }
+
+/* --- task tags (issue #1521) ---------------------------------------------------
+ * A badge takes its tone from a fixed six-colour palette chosen by hashing the
+ * name, so one label always paints the same way and nothing per-tag has to be
+ * stored. The fill is translucent and the text keeps the theme's own primary
+ * label colour, so badges stay readable on light, dark, and every skin without
+ * depending on a token a skin may not define.
+ * ----------------------------------------------------------------------------- */
+
+.cardTags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+}
+
+.cardTag {
+  max-width: 100%;
+  padding: 0 7px;
+  overflow: hidden;
+  border: 1px solid var(--dsh-task-tag-border);
+  border-radius: 999px;
+  background: var(--dsh-task-tag-fill);
+  color: var(--dsw-alias-label-primary);
+  font-size: 10px;
+  line-height: 16px;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.tagFilter {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px;
+  margin: 0 0 10px;
+}
+
+.tagFilterLabel {
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 11px;
+}
+
+.tagChip {
+  padding: 1px 9px;
+  border: 1px solid var(--dsh-task-tag-border);
+  border-radius: 999px;
+  background: transparent;
+  color: var(--dsw-alias-label-secondary);
+  cursor: pointer;
+  font-family: inherit;
+  font-size: 11px;
+  line-height: 18px;
+}
+
+.tagChip[data-active='true'] {
+  background: var(--dsh-task-tag-fill);
+  color: var(--dsw-alias-label-primary);
+}
+
+.cardTag[data-tag-tone='0'],
+.tagChip[data-tag-tone='0'] {
+  --dsh-task-tag-fill: #4e93e82e;
+  --dsh-task-tag-border: #4e93e866;
+}
+
+.cardTag[data-tag-tone='1'],
+.tagChip[data-tag-tone='1'] {
+  --dsh-task-tag-fill: #2ea36a2e;
+  --dsh-task-tag-border: #2ea36a66;
+}
+
+.cardTag[data-tag-tone='2'],
+.tagChip[data-tag-tone='2'] {
+  --dsh-task-tag-fill: #d08a2a2e;
+  --dsh-task-tag-border: #d08a2a66;
+}
+
+.cardTag[data-tag-tone='3'],
+.tagChip[data-tag-tone='3'] {
+  --dsh-task-tag-fill: #b456c82e;
+  --dsh-task-tag-border: #b456c866;
+}
+
+.cardTag[data-tag-tone='4'],
+.tagChip[data-tag-tone='4'] {
+  --dsh-task-tag-fill: #cf5f7a2e;
+  --dsh-task-tag-border: #cf5f7a66;
+}
+
+.cardTag[data-tag-tone='5'],
+.tagChip[data-tag-tone='5'] {
+  --dsh-task-tag-fill: #4a9fb52e;
+  --dsh-task-tag-border: #4a9fb566;
+}
+
+.fieldHint {
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 11px;
+  line-height: 1.4;
+}
+
+.tagRow {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.tagRow .input {
+  flex: 1 1 0;
+  min-width: 0;
+}
+
+.tagRow .ghostButton {
+  flex: none;
+}
+
+.tagAddButton {
+  align-self: flex-start;
+}

package/src/client/body-mutations.ts

@@ -0,0 +1,133 @@
+// Generated by scripts/sync-shared.mjs from shared/client/body-mutations.ts. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
+/**
+ * One `document.body` MutationObserver per page, shared by every family
+ * plugin bundle.
+ *
+ * Family plugins that inject at the DOM level must notice when the shell
+ * re-renders around their injected node: the sidebar entry rows
+ * (sidebar-entry-core), the center-column panel containers
+ * (panel-mount-core), and the aggregate shell's column shims. Each consumer
+ * used to install its OWN `MutationObserver` on `document.body` with
+ * `{ childList: true, subtree: true }`, so a page carrying N family plugins
+ * paid N native observers and N callback invocations for EVERY mutation batch
+ * the app produced — chat token streaming alone produces many per second, and
+ * the count grows with the number of installed plugins.
+ *
+ * This module keeps exactly ONE body observer per page. The registry lives on
+ * `globalThis` under a `Symbol.for` key, so the per-package generated copies
+ * of this file (scripts/sync-shared.mjs) and separately bundled plugins all
+ * reach the same hub at runtime instead of one hub per module instance.
+ * Record subscribers receive the mutations accumulated since the last flush.
+ * Consumers that only re-check their DOM use subscribeBodyInvalidations:
+ * when all subscribers use that path, the hub retains no mutation records
+ * (or detached subtrees) while a background page's animation frames pause.
+ * Both paths run at most once per frame. The last subscriber disconnects the
+ * observer, cancels the pending frame and releases its records.
+ *
+ * Failure policy: without a DOM or `MutationObserver` the subscription is a
+ * no-op disposer (the same silence the per-consumer observers had), and when
+ * `requestAnimationFrame` is unavailable the flush runs synchronously so a
+ * subscriber is never silently dropped. A throwing subscriber cannot stop the
+ * others.
+ */
+
+/** The page-wide hub: one observer plus its subscribers and pending records. */
+interface BodyMutationHub {
+  observer: MutationObserver
+  subscribers: Set<(records: MutationRecord[]) => void>
+  pending: MutationRecord[]
+  scheduled: boolean
+  frame?: number
+}
+
+/** Cross-bundle registry key; `Symbol.for` so every module copy agrees. */
+const HUB_KEY = Symbol.for('dsh-web.body-mutation-hub')
+const INVALIDATION_ONLY = Symbol.for('dsh-web.body-mutation-invalidation')
+type Subscriber = ((records: MutationRecord[]) => void) & { [INVALIDATION_ONLY]?: true }
+
+function needsRecords(subscribers: Set<(records: MutationRecord[]) => void>): boolean {
+  for (const listener of subscribers) {
+    if (!(listener as Subscriber)[INVALIDATION_ONLY]) return true
+  }
+  return false
+}
+
+/**
+ * Subscribe to a coalesced DOM re-check without retaining mutation records.
+ * The marked wrapper also works with an older hub, which delivers records
+ * that it simply ignores until a page reload picks up the updated hub.
+ */
+export function subscribeBodyInvalidations(subscriber: () => void): () => void {
+  const listener: Subscriber = () => { subscriber() }
+  listener[INVALIDATION_ONLY] = true
+  return subscribeBodyMutations(listener)
+}
+
+/**
+ * Subscribe to body-level childList mutations.
+ * @param subscriber - called at most once per animation frame with the records
+ *   collected since the previous flush; must be safe to run repeatedly.
+ * @returns the disposer removing this subscriber (and the observer when it was
+ *   the last one).
+ */
+export function subscribeBodyMutations(subscriber: (records: MutationRecord[]) => void): () => void {
+  if (typeof globalThis === 'undefined' || typeof document === 'undefined') return () => {}
+  if (typeof MutationObserver !== 'function') return () => {}
+  const registry = globalThis as unknown as Record<symbol, unknown>
+  let hub = registry[HUB_KEY] as BodyMutationHub | undefined
+  if (hub === undefined) {
+    const subscribers = new Set<(records: MutationRecord[]) => void>()
+    const created: BodyMutationHub = {
+      observer: undefined as unknown as MutationObserver,
+      subscribers,
+      pending: [],
+      scheduled: false,
+    }
+    const flush = (): void => {
+      created.frame = undefined
+      created.scheduled = false
+      const batch = created.pending
+      created.pending = []
+      for (const listener of [...subscribers]) {
+        if (!subscribers.has(listener)) continue
+        try {
+          listener(batch)
+        } catch {
+          // One subscriber must never break the others; the next flush retries it.
+        }
+      }
+    }
+    const schedule = (): void => {
+      if (created.scheduled) return
+      created.scheduled = true
+      if (typeof requestAnimationFrame === 'function') created.frame = requestAnimationFrame(flush)
+      else flush()
+    }
+    created.observer = new MutationObserver((records) => {
+      if (needsRecords(subscribers)) {
+        for (const record of records) created.pending.push(record)
+      }
+      schedule()
+    })
+    created.observer.observe(document.body ?? document.documentElement, { childList: true, subtree: true })
+    registry[HUB_KEY] = created
+    hub = created
+  }
+  const active = hub
+  active.subscribers.add(subscriber)
+  let subscribed = true
+  return () => {
+    if (!subscribed) return
+    subscribed = false
+    active.subscribers.delete(subscriber)
+    if (!needsRecords(active.subscribers)) active.pending = []
+    if (active.subscribers.size === 0 && registry[HUB_KEY] === active) {
+      active.observer.disconnect()
+      if (active.frame !== undefined && typeof cancelAnimationFrame === 'function') cancelAnimationFrame(active.frame)
+      active.frame = undefined
+      active.pending = []
+      active.scheduled = false
+      delete registry[HUB_KEY]
+    }
+  }
+}

package/src/client/index.ts

@@ -80,7 +80,7 @@ declare module '@deepseek-ai/cordis' {
  * on hosts below that cohort, which serve the same roster through the
  * connection RPC face.
  */
-export const inject = ['slots', 'sessions', 'workspaces', 'connection', 'settingsScope', 'locale', 'remote']
+export const inject = ['slots', 'sessions', 'workspaces', 'connection', 'settingsScope', 'locale', 'remote', 'remote.session']
 
 /** One agent-preset row the mode picker consumes (either face's wire shape). */
 interface PresetRosterRow {
@@ -251,31 +251,63 @@ export function apply(ctx: ClientContext): void {
     }
     const pushModelOptions = async (): Promise<void> => {
       try {
-        const conn = ctx.get('connection') as { api?: { llm?: { discoverModels?: () => Promise<unknown> }; sessions?: { modelCatalog?: () => Promise<unknown> } } } | undefined
-        if (conn?.api) {
-          let models: Array<{ id: string; name?: string; provider?: string }> = []
-          if (typeof conn.api.llm?.discoverModels === 'function') {
-            const res = await conn.api.llm.discoverModels() as { result?: { value?: { models?: Array<{ id: string; name?: string }> } } }
-            const list = res?.result?.value?.models
-            if (Array.isArray(list)) {
-              models = list.map(m => ({ id: m.id, name: m.name }))
+        let models: Array<{ id: string; name?: string; provider?: string }> = []
+        let sessionRemote: ClientRemote['session'] | undefined
+        try {
+          sessionRemote = (remote as Partial<ClientRemote>).session
+        } catch {
+          sessionRemote = undefined
+        }
+        if (typeof sessionRemote?.modelCatalog === 'function') {
+          const res = await sessionRemote.modelCatalog()
+          if (res.ok && Array.isArray(res.value?.groups)) {
+            for (const g of res.value.groups) {
+              const provider = (g as { id?: string; provider?: string }).id ?? (g as { id?: string; provider?: string }).provider
+              for (const m of g.models ?? []) {
+                const qualifiedId = provider ? `${provider}/${m.id}` : m.id
+                models.push({ id: qualifiedId, name: m.name ?? m.id, provider })
+              }
             }
           }
-          if (models.length === 0 && typeof conn.api.sessions?.modelCatalog === 'function') {
-            const res = await conn.api.sessions.modelCatalog() as { result?: { value?: { groups?: Array<{ provider?: string; models?: Array<{ id: string; name?: string }> }> } } }
-            const groups = res?.result?.value?.groups
-            if (Array.isArray(groups)) {
-              for (const g of groups) {
-                for (const m of g.models ?? []) {
-                  const qualifiedId = g.provider ? `${g.provider}/${m.id}` : m.id
-                  models.push({ id: qualifiedId, name: m.name ?? m.id, provider: g.provider })
+        }
+        if (models.length === 0) {
+          const conn = ctx.get('connection') as {
+            api?: {
+              llm?: { discoverModels?: () => Promise<unknown> }
+              sessions?: { modelCatalog?: () => Promise<unknown> }
+              session?: { modelCatalog?: () => Promise<unknown> }
+            }
+          } | undefined
+          if (conn?.api) {
+            if (typeof conn.api.llm?.discoverModels === 'function') {
+              const res = await conn.api.llm.discoverModels() as { result?: { value?: { models?: Array<{ id: string; name?: string }> } } }
+              const list = res?.result?.value?.models
+              if (Array.isArray(list)) {
+                models = list.map(m => ({ id: m.id, name: m.name }))
+              }
+            }
+            const catalogFn = typeof conn.api.session?.modelCatalog === 'function'
+              ? conn.api.session.modelCatalog
+              : typeof conn.api.sessions?.modelCatalog === 'function'
+                ? conn.api.sessions.modelCatalog
+                : undefined
+            if (models.length === 0 && catalogFn !== undefined) {
+              const res = await catalogFn() as { result?: { value?: { groups?: Array<{ id?: string; provider?: string; models?: Array<{ id: string; name?: string }> }> } } }
+              const groups = res?.result?.value?.groups
+              if (Array.isArray(groups)) {
+                for (const g of groups) {
+                  const provider = g.id ?? g.provider
+                  for (const m of g.models ?? []) {
+                    const qualifiedId = provider ? `${provider}/${m.id}` : m.id
+                    models.push({ id: qualifiedId, name: m.name ?? m.id, provider })
+                  }
                 }
               }
             }
           }
-          if (models.length > 0) {
-            controller.setExecutionOptions({ models })
-          }
+        }
+        if (models.length > 0) {
+          controller.setExecutionOptions({ models })
         }
       } catch (error) {
         console.error('[dsh-task-board] model options read failed', error)

package/src/client/locales.ts

@@ -55,6 +55,17 @@ export const zh = {
   'detail.handover': '交接包',
   'detail.handover.bundledAt': '打包于 {time}',
   'detail.handover.references': '引用',
+  'new.tags': '标签（可选）',
+  'new.tagsHint': '标签用于卡片徽章与顶栏筛选；填了「执行提示」的行会在每次执行前注入 Prompt，留空则只作展示。',
+  'new.tagName': '标签名',
+  'new.tagNamePlaceholder': '例如：工作',
+  'new.tagPrompt': '执行提示（可选）',
+  'new.tagPromptPlaceholder': '例如：产物归档到 02-工作/',
+  'new.tagAdd': '添加标签',
+  'new.tagRemove': '移除标签 {name}',
+  'board.tagFilter': '按标签筛选',
+  'board.tagFilterClear': '清除标签筛选',
+  'board.tagEmpty': '没有同时带这些标签的任务',
   'detail.permissionPending': '权限待确认：本卡有效权限（{permission}）高于会话默认，手动执行与定时调度都会被拒绝，需人工确认后才能运行。',
   'detail.permissionConfirm': '确认权限绑定',
   'detail.permissionConfirmed': '已确认权限绑定 · {time}',
@@ -209,6 +220,17 @@ export const en: Record<keyof typeof zh, string> = {
   'detail.handover': 'Handover bundle',
   'detail.handover.bundledAt': 'Bundled at {time}',
   'detail.handover.references': 'References',
+  'new.tags': 'Tags (optional)',
+  'new.tagsHint': 'Tags drive the card badges and the board filter; a row with an execution hint is injected ahead of the prompt on every run, an empty one is display-only.',
+  'new.tagName': 'Tag name',
+  'new.tagNamePlaceholder': 'e.g. Work',
+  'new.tagPrompt': 'Execution hint (optional)',
+  'new.tagPromptPlaceholder': 'e.g. Archive artefacts under 02-work/',
+  'new.tagAdd': 'Add tag',
+  'new.tagRemove': 'Remove tag {name}',
+  'board.tagFilter': 'Filter by tag',
+  'board.tagFilterClear': 'Clear tag filter',
+  'board.tagEmpty': 'No task carries all of these tags',
   'detail.permissionPending': 'Permission pending confirmation: this card\'s effective permission ({permission}) is above the session default; manual runs and cron are refused until a human confirms.',
   'detail.permissionConfirm': 'Confirm permission binding',
   'detail.permissionConfirmed': 'Permission confirmed · {time}',