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

package/src/client/host-api.ts

@@ -1,9 +1,13 @@
 import type { TaskRecord } from '../core/tasks.ts'
+import { t } from './locales.ts'
 import {
+  isTaskParseDraft,
   TASK_BOARD_API_PREFIX,
   type TaskBoardAction,
   type TaskBoardActionEnvelope,
   type TaskBoardEventPayload,
+  type TaskBoardParseDraft,
+  type TaskBoardParseRequest,
   type TaskBoardSnapshot,
 } from '../protocol.ts'
 
@@ -11,15 +15,69 @@ const IMPORT_MARKER = 'dsh.taskBoard.v2.hostImported'
 const SOURCE_KEY = 'dsh.taskBoard.v2.sourceId'
 const IMPORT_REQUEST_KEY = 'dsh.taskBoard.v2.importRequestId'
 const REQUEST_TIMEOUT_MS = 15_000
+/** Re-notify the panel at most this often while the event stream stays broken. */
+const STREAM_ERROR_NOTIFY_MS = 15_000
+/** Mirrors the Host's own parse budget; only used to phrase the timeout. */
+const TASK_PARSE_TIMEOUT_SECONDS = 45
+
+/**
+ * Failure classes of the Host API, in the language the panel renders
+ * (issue #1528). The Host is the only part that knows whether a task-board
+ * route exists at all, so a raw fetch/parse error must never reach the user:
+ * "Unexpected token 'o', \"not found\" is not valid JSON" is what a missing
+ * Host half looks like today.
+ */
+export type HostApiFailure = 'not-mounted' | 'unauthorized' | 'locked' | 'rejected' | 'timeout' | 'unreachable' | 'unexpected'
+
+/** Transport failure carrying a stable class next to its user-facing message. */
+export class HostApiError extends Error {
+  constructor(readonly failure: HostApiFailure, message: string, readonly status?: number) {
+    super(message)
+    this.name = 'HostApiError'
+  }
+}
 
 function uuid(): string {
   return globalThis.crypto?.randomUUID?.() ?? `browser-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`
 }
 
+/**
+ * Read one Host response without ever handing a non-JSON body to JSON.parse:
+ * the core webserver answers an unmounted `/api/*` path with the plain text
+ * "not found", which used to surface as a JavaScript parse error in the panel.
+ */
 async function readJson<T>(response: Response): Promise<T> {
-  const body = await response.json() as T & { error?: string }
-  if (!response.ok) throw new Error(body.error ?? `task-board request failed: ${response.status}`)
-  return body
+  const text = await response.text()
+  let parsed: unknown
+  let readable = false
+  if (text.trim() !== '') {
+    try {
+      parsed = JSON.parse(text)
+      readable = true
+    } catch {
+      readable = false
+    }
+  }
+  const hostError = readable && typeof parsed === 'object' && parsed !== null && typeof (parsed as { error?: unknown }).error === 'string'
+    ? (parsed as { error: string }).error
+    : undefined
+  if (response.ok) {
+    if (!readable) throw new HostApiError('unexpected', t('board.hostError.unexpected', { status: String(response.status) }), response.status)
+    return parsed as T
+  }
+  if (hostError !== undefined) {
+    // The Host answered with a reason of its own. A ledger lock is the one
+    // class worth naming in the panel's words; the authentication fence and
+    // every other action rejection are reported as they arrive.
+    if (hostError === 'forbidden') throw new HostApiError('unauthorized', t('board.hostError.unauthorized'), response.status)
+    if (response.status === 503 || /lock/i.test(hostError)) {
+      throw new HostApiError('locked', t('board.hostError.locked', { detail: hostError }), response.status)
+    }
+    throw new HostApiError('rejected', hostError, response.status)
+  }
+  if (response.status === 404) throw new HostApiError('not-mounted', t('board.hostError.notMounted'), 404)
+  if (response.status === 401 || response.status === 403) throw new HostApiError('unauthorized', t('board.hostError.unauthorized'), response.status)
+  throw new HostApiError('unexpected', t('board.hostError.unexpected', { status: String(response.status) }), response.status)
 }
 
 export interface TaskBoardHostTransport {
@@ -27,6 +85,8 @@ export interface TaskBoardHostTransport {
   state(): Promise<TaskBoardSnapshot>
   action(action: TaskBoardAction, initiator?: string): Promise<TaskBoardSnapshot>
   subscribe(listener: (event?: TaskBoardEventPayload) => void): () => void
+  /** One-shot model parse of pasted text (issue #1540). */
+  parseDraft(request: TaskBoardParseRequest, signal?: AbortSignal): Promise<TaskBoardParseDraft>
 }
 
 export class HttpTaskBoardHostTransport implements TaskBoardHostTransport {
@@ -76,15 +136,65 @@ export class HttpTaskBoardHostTransport implements TaskBoardHostTransport {
     try {
       return await readJson<TaskBoardSnapshot>(await fetch(url, { ...init, signal: controller.signal }))
     } catch (error) {
-      if (controller.signal.aborted) throw new Error(`task-board Host request timed out after ${REQUEST_TIMEOUT_MS / 1_000}s`)
-      throw error
+      if (error instanceof HostApiError) throw error
+      if (controller.signal.aborted) throw new HostApiError('timeout', t('board.hostError.timeout', { seconds: String(REQUEST_TIMEOUT_MS / 1_000) }))
+      // fetch itself failed (server stopped, connection reset, DNS): the panel
+      // says so in its own words instead of leaking "Failed to fetch".
+      throw new HostApiError('unreachable', t('board.hostError.unreachable'))
     } finally {
       globalThis.clearTimeout(timeout)
     }
   }
 
+  /**
+   * Ask the Host to turn pasted text into task fields. The route answers a
+   * typed failure (no model, timeout, unparseable reply) already phrased for
+   * the form, so the UI never renders a raw status code (issue #1540).
+   */
+  async parseDraft(request: TaskBoardParseRequest, signal?: AbortSignal): Promise<TaskBoardParseDraft> {
+    let response: Response
+    try {
+      response = await fetch(`${TASK_BOARD_API_PREFIX}/parse`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(request),
+        ...(signal === undefined ? {} : { signal }),
+      })
+    } catch {
+      // A cancelled parse and a stopped Host look the same to fetch; the form
+      // checks its own abort flag before showing anything.
+      throw new HostApiError('unreachable', t('board.hostError.unreachable'))
+    }
+    const text = await response.text()
+    let parsed: unknown
+    let readable = false
+    if (text.trim() !== '') {
+      try {
+        parsed = JSON.parse(text)
+        readable = true
+      } catch {
+        readable = false
+      }
+    }
+    const record = readable && typeof parsed === 'object' && parsed !== null
+      ? parsed as { code?: unknown; error?: unknown; draft?: unknown }
+      : undefined
+    if (response.ok) {
+      if (record !== undefined && isTaskParseDraft(record.draft)) return record.draft
+      throw new HostApiError('unexpected', t('new.aiParseFailed', { error: t('board.hostError.unexpected', { status: String(response.status) }) }), response.status)
+    }
+    if (response.status === 404) throw new HostApiError('not-mounted', t('new.aiParseUnavailable'), 404)
+    if (response.status === 401 || response.status === 403) throw new HostApiError('unauthorized', t('board.hostError.unauthorized'), response.status)
+    const code = typeof record?.code === 'string' ? record.code : undefined
+    if (code === 'no-model') throw new HostApiError('rejected', t('new.aiParseNoModel'), response.status)
+    if (code === 'timeout') throw new HostApiError('timeout', t('new.aiParseTimeout', { seconds: String(TASK_PARSE_TIMEOUT_SECONDS) }), response.status)
+    const detail = typeof record?.error === 'string' && record.error !== '' ? record.error : String(response.status)
+    throw new HostApiError('rejected', t('new.aiParseFailed', { error: detail }), response.status)
+  }
+
   subscribe(listener: (event?: TaskBoardEventPayload) => void): () => void {
     const events = new EventSource(`${TASK_BOARD_API_PREFIX}/events`)
+    let lastStreamErrorNotify = 0
     events.onmessage = (message: MessageEvent<string>): void => {
       try {
         const parsed = JSON.parse(message.data) as TaskBoardEventPayload
@@ -94,6 +204,15 @@ export class HttpTaskBoardHostTransport implements TaskBoardHostTransport {
         listener()
       }
     }
+    // A stream that cannot connect at all (unmounted route, refused socket) is
+    // how a Host half that never mounted looks from the browser; nudge the
+    // panel into one state read so the failure becomes visible (#1528).
+    events.onerror = (): void => {
+      const now = Date.now()
+      if (now - lastStreamErrorNotify < STREAM_ERROR_NOTIFY_MS) return
+      lastStreamErrorNotify = now
+      listener()
+    }
     const onVisible = (): void => { if (document.visibilityState === 'visible') listener() }
     document.addEventListener('visibilitychange', onVisible)
     return () => {

package/src/client/index.ts

@@ -30,6 +30,7 @@ import { TaskBoardSettingsCard, TaskBoardSettingsCardController, type TaskBoardS
 import { en, zh, setRuntimeTranslate, type TaskBoardKey } from './locales.ts'
 import { HttpTaskBoardHostTransport } from './host-api.ts'
 import { reportDailyHeartbeat } from './telemetry.ts'
+import { installPluginCard } from './plugin-card-seat.ts'
 
 /** Locale namespace this plugin owns. */
 const NS = 'task-board'
@@ -164,27 +165,20 @@ export function apply(ctx: ClientContext): void {
   try { setRuntimeTranslate(ctx.locale.bind(NS)) } catch { /* locale missing: document-language fallback stays */ }
 
   // Plugin configuration card: one staged form over the `task-board` settings
-  // namespace, contributed to the Web UI plugin group.
+  // namespace, contributed to whichever plugin-card seat this host declares
+  // (issue #1589).
   const binder = ctx.get('webUiSettings') ?? ctx.settingsScope
   const settingsScope = binder.bind<TaskBoardSettings>({ namespace: TASK_BOARD_NS })
   const settingsCard = new TaskBoardSettingsCardController(settingsScope)
-  ctx.slots.inject('web-ui.plugin.item', () => {
-    try {
-      const unregister = ctx.slots.register({
-        name: 'web-ui.plugin.item',
-        id: 'task-board',
-        order: 110,
-        locale: NS,
-        inject: () => settingsCard.inject(),
-      }, TaskBoardSettingsCard)
-      return () => {
-        settingsCard.dispose()
-        unregister()
-      }
-    } catch {
-      return () => {}
-    }
+  installPluginCard(ctx, {
+    namespace: TASK_BOARD_NS,
+    id: 'task-board',
+    order: 110,
+    locale: NS,
+    inject: () => settingsCard.inject(),
+    component: TaskBoardSettingsCard,
   })
+  ctx.effect(() => () => { settingsCard.dispose() }, 'task-board: settings card')
 
   // The sidebar entry and board view mount once the settings scope settles;
   // while the scope is still loading, the composition default is unknown, so
@@ -230,6 +224,13 @@ export function apply(ctx: ClientContext): void {
     }
     pushWorkspaceOptions()
     disposers.push(workspaces.list.subscribe(pushWorkspaceOptions))
+    // "New project" on the board is the GUI's own add-project call (#1536);
+    // the runtime emits the created Workspace through workspaces.list, which
+    // refreshes the filter above without a local re-read.
+    controller.setWorkspaceCreator(async path => {
+      const created = await workspaces.create({ path })
+      return { workspaceId: created.workspaceId }
+    })
     const pushPresetOptions = async (): Promise<void> => {
       try {
         const roster = await readPresetRoster(ctx, remote)

package/src/client/locales.ts

@@ -29,6 +29,30 @@ export const zh = {
   'board.updated': '更新于',
   'board.created': '创建于',
   'board.hostError': 'Host 操作失败：{error}',
+  'board.hostError.notMounted': '任务看板的后台接口没有挂载：宿主可能没有加载该插件，也可能后台数据正被另一个 DSH 实例占用。重启 DSH 服务后再试',
+  'board.hostError.unauthorized': '登录状态已失效，请刷新页面后重试',
+  'board.hostError.locked': '任务看板的后台数据被占用：{detail}',
+  'board.hostError.timeout': '后台 {seconds} 秒内没有响应，请稍后重试',
+  'board.hostError.unreachable': '连接不上本机 DSH 服务，请确认它仍在运行',
+  'board.hostError.unexpected': '后台返回了无法识别的响应（HTTP {status}）',
+  'board.project': '项目',
+  'board.projectAll': '全部项目',
+  'board.projectNew': '新建项目…',
+  'board.projectNewPath': '项目目录（宿主上的绝对路径）',
+  'board.projectNewPathPlaceholder': '例如 C:\\work\\my-project 或 /home/me/project',
+  'board.projectCreate': '创建项目',
+  'board.projectCreateFailed': '创建项目失败：{error}',
+  'new.aiParse': 'AI 解析',
+  'new.aiParseHint': '把从别处复制的一段话粘进来，让模型整理成标题、描述和执行 Prompt；解析结果只填进下面的表单，你可以先改再创建。',
+  'new.aiParsePlaceholder': '粘贴要变成任务的内容…',
+  'new.aiParseModel': '解析用模型',
+  'new.aiParseRun': '解析并填入',
+  'new.aiParseCancel': '取消解析',
+  'new.aiParseEmpty': '先粘贴一段内容再解析',
+  'new.aiParseNoModel': '这个部署还没有可用的模型，请先在 DSH 里配置模型提供商，或换一个模型再试',
+  'new.aiParseUnavailable': '后台没有解析接口可用，重启 DSH 服务后再试',
+  'new.aiParseTimeout': '模型 {seconds} 秒内没有返回结果，请重试或换一个更快的模型',
+  'new.aiParseFailed': '解析失败：{error}',
   'board.retryHost': '重试连接 Host',
   'board.hostMeta': 'Host 时区 {timeZone} · revision {revision}',
   'new.title': '标题',
@@ -38,6 +62,7 @@ export const zh = {
   'new.prompt': '执行 Prompt',
   'new.promptPlaceholder': '发给 agent 的完整指令（留空则使用标题）',
   'new.submit': '创建',
+  'new.createAndRun': '创建并执行',
   'new.cancel': '取消',
   'new.required': '标题不能为空',
   'new.freeze': '冻结快照（可选）',
@@ -71,6 +96,7 @@ export const zh = {
   'detail.permissionConfirmed': '已确认权限绑定 · {time}',
   'detail.title': '任务详情',
   'detail.edit': '编辑',
+  'detail.editTags': '编辑标签',
   'detail.duplicate': '复制为新任务',
   'detail.duplicateAndEdit': '修改并新建副本',
   'detail.close': '关闭',
@@ -194,6 +220,30 @@ export const en: Record<keyof typeof zh, string> = {
   'board.updated': 'Updated',
   'board.created': 'Created',
   'board.hostError': 'Host action failed: {error}',
+  'board.hostError.notMounted': 'The task board Host API is not mounted: the Host may not have loaded the plugin, or another DSH instance holds the ledger. Restart the DSH service and try again',
+  'board.hostError.unauthorized': 'This session is no longer signed in; reload the page and try again',
+  'board.hostError.locked': 'The task board ledger is locked: {detail}',
+  'board.hostError.timeout': 'The Host did not answer within {seconds}s; try again shortly',
+  'board.hostError.unreachable': 'Cannot reach the local DSH service; make sure it is still running',
+  'board.hostError.unexpected': 'The Host returned an unrecognized response (HTTP {status})',
+  'board.project': 'Project',
+  'board.projectAll': 'All projects',
+  'board.projectNew': 'New project…',
+  'board.projectNewPath': 'Project directory (absolute path on the Host)',
+  'board.projectNewPathPlaceholder': 'e.g. C:\\work\\my-project or /home/me/project',
+  'board.projectCreate': 'Create project',
+  'board.projectCreateFailed': 'Could not create the project: {error}',
+  'new.aiParse': 'Parse with AI',
+  'new.aiParseHint': 'Paste text copied from somewhere else and let a model turn it into a title, description, and run prompt; the result only fills the form below, so you can edit it before creating the task.',
+  'new.aiParsePlaceholder': 'Paste the content to turn into a task…',
+  'new.aiParseModel': 'Model used for parsing',
+  'new.aiParseRun': 'Parse and fill',
+  'new.aiParseCancel': 'Cancel parsing',
+  'new.aiParseEmpty': 'Paste something to parse first',
+  'new.aiParseNoModel': 'This deployment has no model available; configure a model provider in DSH or pick another model',
+  'new.aiParseUnavailable': 'The Host has no parse endpoint; restart the DSH service and try again',
+  'new.aiParseTimeout': 'The model did not answer within {seconds}s; try again or pick a faster model',
+  'new.aiParseFailed': 'Parsing failed: {error}',
   'board.retryHost': 'Retry Host connection',
   'board.hostMeta': 'Host time zone {timeZone} · revision {revision}',
   'new.title': 'Title',
@@ -203,6 +253,7 @@ export const en: Record<keyof typeof zh, string> = {
   'new.prompt': 'Run Prompt',
   'new.promptPlaceholder': 'The full instruction sent to the agent (title is used when blank)',
   'new.submit': 'Create',
+  'new.createAndRun': 'Create and run',
   'new.cancel': 'Cancel',
   'new.required': 'Title is required',
   'new.freeze': 'Frozen snapshot (optional)',
@@ -236,6 +287,7 @@ export const en: Record<keyof typeof zh, string> = {
   'detail.permissionConfirmed': 'Permission confirmed · {time}',
   'detail.title': 'Task Detail',
   'detail.edit': 'Edit',
+  'detail.editTags': 'Edit tags',
   'detail.duplicate': 'Duplicate Task',
   'detail.duplicateAndEdit': 'Edit as New Copy',
   'detail.close': 'Close',

package/src/client/plugin-card-seat.ts

@@ -0,0 +1,185 @@
+// Generated by scripts/sync-shared.mjs from shared/client/settings/plugin-card-seat.ts. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
+/**
+ * Family plugin-card seat.
+ *
+ * A family plugin contributes its settings card to whichever plugin-card seat
+ * the running host actually renders:
+ *
+ * - `web-ui.plugin.item` — the list seat declared by the dsh-web-settings
+ *   group section (this family's own first-level "Web UI plugins" section);
+ * - `settings.plugin.item` — the official keyed seat of the harness's
+ *   `ui-settings-plugins` tab, keyed by the settings namespace the card edits.
+ *
+ * SEAT SELECTION IS NOT A DECLARATION PROBE. The official `ui-settings-plugins`
+ * row belongs to the harness bundle and its `configurable` tab always declares
+ * `settings.plugin.item` before any external plugin's `apply()` runs, so
+ * "is the official seat declared?" answers yes even in the deployment whose
+ * whole point is the family group. Choosing on that probe sends every family
+ * card to the official Plugins tab and leaves the group's own section
+ * permanently empty — the family of reports where the section renders its
+ * heading and zero cards.
+ *
+ * The signal that actually distinguishes the two deployments is whether
+ * dsh-web-settings is loaded: it is the package that owns the group section and
+ * it publishes the `webUiSettings` service during `apply()`, which every
+ * family plugin already reads for its settings scope. Group loaded -> the family
+ * seat; group absent -> the official seat.
+ *
+ * The decision is re-evaluated on every `slots/changed` because the group may
+ * apply after this plugin (the family aggregate orders it first, a profile that
+ * installs the group separately need not): the initial contribution goes to the
+ * official seat, then moves to the family seat the moment the group's section
+ * registers. The entry is disposed before the replacement is registered, so a
+ * card is never in two seats at once.
+ *
+ * The shared tree has no client-SDK dependency, so this module reads its
+ * context through the structural shape below; callers pass the plugin's own
+ * `ctx`.
+ */
+
+/** The family list seat key. */
+export const FAMILY_PLUGIN_CARD_SEAT = 'web-ui.plugin.item'
+
+/** The official keyed plugin-card seat key. */
+export const OFFICIAL_PLUGIN_CARD_SEAT = 'settings.plugin.item'
+
+/** The service dsh-web-settings publishes while it is loaded. */
+export const FAMILY_GROUP_SERVICE = 'webUiSettings'
+
+/** The slot-registry member this helper uses (structurally satisfied by ctx.slots). */
+export interface PluginCardSlots {
+  /** Contribution of one card entry. */
+  register(options: never, component: never): unknown
+}
+
+/** The slice of the client context a card contribution needs. */
+export interface PluginCardContext {
+  slots: PluginCardSlots
+  /** Service lookup; absent on a context double that only models the slots. */
+  get?(name: string): unknown
+  /** Event subscription seat; absent on an event-less test double. */
+  on?(event: string, listener: (...args: never[]) => void): unknown
+}
+
+/** Owner share of a plugin card (both seats supply nothing). */
+export interface SettingsPluginItemOwnerProps {
+  /** Marker field: card owner props are intentionally empty. */
+  children?: never
+}
+
+/** One family plugin's card contribution. */
+export interface PluginCardSeat {
+  /** Settings namespace the card edits (the official seat's dispatch key). */
+  namespace: string
+  /** Family list-seat entry id. */
+  id: string
+  /** Family list-seat sort order. */
+  order?: number
+  /** Family list-seat display label; the official keyed seat carries none. */
+  label?: () => string
+  /** Locale namespace the card renders with. */
+  locale: string
+  /** Business-face factory of the registration. */
+  inject?: () => object
+  /**
+   * The card component. Its props type is the seat's composed shape, which is
+   * chosen at runtime, so the helper takes it erased; the registrant keeps its
+   * own precise typing at the call site.
+   */
+  component: unknown
+}
+
+/**
+ * Whether the family group (dsh-web-settings) is loaded in this page. The
+ * service is the group package's own contract, so the probe cannot be fooled
+ * by a harness release that starts declaring the official seat differently.
+ */
+export function familyGroupLoaded(ctx: PluginCardContext): boolean {
+  const get = ctx.get
+  if (typeof get !== 'function') return false
+  try {
+    return get.call(ctx, FAMILY_GROUP_SERVICE) !== undefined
+  } catch {
+    // A context that refuses the lookup: treat the group as absent, which
+    // falls back to the official seat the harness declares.
+    return false
+  }
+}
+
+/** Report a refused registration instead of leaving the user with no card. */
+function warnRefusedSeat(seat: string, error: unknown): void {
+  try {
+    console.warn(`[dsh-web] plugin card registration into "${seat}" was refused; the card will not render`, error)
+  } catch {
+    // Best-effort console write; a failed warning must not break the plugin.
+  }
+}
+
+/**
+ * Contribute one family plugin card to the seat this host renders, following
+ * the group if it loads later. The entry is disposed and re-registered on a
+ * seat change, never duplicated.
+ * @param ctx - client context (its slot registry decides the seat).
+ * @param seat - the card contribution.
+ */
+export function installPluginCard(ctx: PluginCardContext, seat: PluginCardSeat): void {
+  const slots = ctx.slots
+  const component = seat.component as never
+  const inject = seat.inject as never
+
+  let dispose: (() => void) | undefined
+  let current: string | undefined
+  /**
+   * Re-entrancy latch. The registry emits a change event synchronously from
+   * inside both `register` and the previous entry's disposer, so an unguarded
+   * reconcile would re-enter itself mid-move and register the card twice into
+   * the seat it is leaving ("already has an entry for key ...").
+   */
+  let reconciling = false
+
+  /** Reconcile the contribution with the currently live seat (no-op when unchanged). */
+  const reconcile = (): void => {
+    if (reconciling) return
+    const target = familyGroupLoaded(ctx) ? FAMILY_PLUGIN_CARD_SEAT : OFFICIAL_PLUGIN_CARD_SEAT
+    if (current === target) return
+    reconciling = true
+    const previous = dispose
+    dispose = undefined
+    current = undefined
+    previous?.()
+    try {
+      dispose = slots.register((target === FAMILY_PLUGIN_CARD_SEAT
+        ? {
+          name: FAMILY_PLUGIN_CARD_SEAT,
+          id: seat.id,
+          ...(seat.order === undefined ? {} : { order: seat.order }),
+          ...(seat.label === undefined ? {} : { label: seat.label }),
+          locale: seat.locale,
+          ...(seat.inject === undefined ? {} : { inject }),
+        }
+        : {
+          name: OFFICIAL_PLUGIN_CARD_SEAT,
+          key: seat.namespace,
+          locale: seat.locale,
+          ...(seat.inject === undefined ? {} : { inject }),
+        }) as never, component) as () => void
+      current = target
+    } catch (error) {
+      warnRefusedSeat(target, error)
+    } finally {
+      reconciling = false
+    }
+  }
+
+  if (typeof ctx.on === 'function') {
+    try {
+      ctx.on('slots/changed', () => { reconcile() })
+    } catch {
+      // An event seat that refuses the subscription leaves the initial
+      // decision in place; the card still renders in the seat chosen below.
+    }
+  }
+  // The initial decision: the group, when it is already loaded (the aggregate
+  // order), otherwise the official seat the harness declares.
+  reconcile()
+}

package/src/client/sidebar-entry-core.ts

@@ -16,6 +16,33 @@
  */
 import { subscribeBodyInvalidations } from './body-mutations.ts'
 
+/**
+ * One trailing action button seated at the entry row's right edge (e.g. a
+ * refresh command or a collapse chevron). Rows with actions switch from the
+ * classic single-button structure to a container with a main button plus the
+ * action buttons (nested interactive elements are invalid HTML); rows without
+ * actions keep the classic structure untouched.
+ */
+export interface SidebarEntryAction {
+  /** Stable id stamped as data-dsh-entry-action="<id>" (CSS hooks and tests). */
+  id: string
+  /** Inline icon markup while the row is active (always, when inactiveIcon is unset). */
+  icon: string
+  /**
+   * Optional icon while the row is inactive. Setting it makes the action a
+   * state mirror (a collapse chevron): the core swaps the icon and stamps
+   * aria-expanded on every active-state change. Requires the active bridge.
+   */
+  inactiveIcon?: string
+  /** Localized accessible label (aria-label + title); receives the active state. */
+  label(active: boolean): string
+  /**
+   * Click handler; receives the button so the caller can drive transient
+   * affordances (a refresh cooldown) without a re-render.
+   */
+  onClick(button: HTMLButtonElement): void
+}
+
 /** Per-package configuration for one sidebar entry row. */
 export interface SidebarEntryOptions {
   /** Full attribute name identifying the injected row (idempotency key), e.g. 'data-dsh-ssh-entry'. */
@@ -47,6 +74,12 @@ export interface SidebarEntryOptions {
   refresh?: { subscribe(listener: () => void): () => void }
   /** Click action (open/toggle the owning panel). */
   onToggle(): void
+  /**
+   * Optional trailing action buttons at the row's right edge. Requires the
+   * package CSS to seat entryMain / entryAction; empty keeps the classic
+   * single-button row.
+   */
+  actions?: readonly SidebarEntryAction[]
   /** Family-block position: 'before' inserts ahead of sibling plugin rows, 'after' behind them. */
   position: 'before' | 'after'
   /**
@@ -84,10 +117,12 @@ function newSessionButton(root: HTMLElement): HTMLButtonElement | undefined {
   return undefined
 }
 
-/** Build the entry row (a detached button; insert once the shell is up). */
-function createEntry(options: SidebarEntryOptions): { entry: HTMLButtonElement; applyLabel: () => void } {
-  const entry = document.createElement('button')
-  entry.type = 'button'
+/** Build the entry row (detached; inserted once the shell is up). */
+function createEntry(options: SidebarEntryOptions): { entry: HTMLElement; applyLabel: () => void; setOpen: (open: boolean) => void } {
+  const actions = options.actions ?? []
+  const composite = actions.length > 0
+  const entry = document.createElement(composite ? 'div' : 'button') as HTMLElement
+  if (!composite) (entry as HTMLButtonElement).type = 'button'
   entry.setAttribute(options.rowAttribute, '')
   if (options.plugin !== undefined) {
     entry.setAttribute('data-dsh-plugin', options.plugin)
@@ -99,19 +134,66 @@ function createEntry(options: SidebarEntryOptions): { entry: HTMLButtonElement;
   const iconSpan = document.createElement('span')
   iconSpan.className = options.css['entryIcon'] ?? ''
   iconSpan.innerHTML = options.icon
-  entry.append(iconSpan, labelSpan)
+  // The main hit area: the classic row IS the button; with trailing actions
+  // the row becomes a container and the main area its own button, so the row
+  // never nests interactive elements.
+  const main = composite ? document.createElement('button') : (entry as HTMLButtonElement)
+  if (composite) {
+    main.type = 'button'
+    main.className = options.css['entryMain'] ?? ''
+    main.append(iconSpan, labelSpan)
+    entry.append(main)
+  } else {
+    entry.append(iconSpan, labelSpan)
+  }
+  const actionButtons: { action: SidebarEntryAction; button: HTMLButtonElement }[] = []
+  for (const action of actions) {
+    const button = document.createElement('button')
+    button.type = 'button'
+    button.className = options.css['entryAction'] ?? ''
+    button.setAttribute('data-dsh-entry-action', action.id)
+    button.innerHTML = action.icon
+    button.addEventListener('click', () => { action.onClick(button) })
+    entry.append(button)
+    actionButtons.push({ action, button })
+  }
+  let open = false
+  const applyActions = (): void => {
+    for (const { action, button } of actionButtons) {
+      button.innerHTML = open || action.inactiveIcon === undefined ? action.icon : action.inactiveIcon
+      const text = action.label(open)
+      button.setAttribute('aria-label', text)
+      button.setAttribute('title', text)
+      if (action.inactiveIcon !== undefined) button.setAttribute('aria-expanded', String(open))
+    }
+  }
   const applyLabel = (): void => {
-    entry.setAttribute('aria-label', options.label())
-    if (options.tooltip !== undefined) entry.setAttribute('title', options.tooltip())
+    main.setAttribute('aria-label', options.label())
+    if (options.tooltip !== undefined) main.setAttribute('title', options.tooltip())
     labelSpan.textContent = options.label()
+    applyActions()
   }
   applyLabel()
-  entry.addEventListener('click', options.onToggle)
-  return { entry, applyLabel }
+  main.addEventListener('click', options.onToggle)
+  if (composite) {
+    // The old row was clickable edge to edge; keep the padding between the
+    // main area and the action buttons a toggle target as well.
+    entry.addEventListener('click', (event) => {
+      if (event.target === entry) options.onToggle()
+    })
+  }
+  return {
+    entry,
+    applyLabel,
+    setOpen: (next: boolean) => {
+      open = next
+      applyActions()
+    },
+  }
 }
 
 /** Re-insert the entry after the New Session row (before the browser region). */
-function placeEntry(root: HTMLElement, entry: HTMLButtonElement, options: SidebarEntryOptions): boolean {
+function placeEntry(root: HTMLElement, entry: HTMLElement, options: SidebarEntryOptions): boolean {
   const button = newSessionButton(root)
   if (button === undefined) return false
   if (entry.parentElement !== root) {
@@ -149,7 +231,7 @@ export function mountSidebarEntry(options: SidebarEntryOptions): () => void {
   if (typeof document !== 'undefined' && document.querySelector(options.rowSelector) !== null) {
     return () => {}
   }
-  const { entry, applyLabel } = createEntry(options)
+  const { entry, applyLabel, setOpen } = createEntry(options)
   let root: HTMLElement | undefined
   let placed = false
   let unsubscribeRefresh: (() => void) | undefined
@@ -217,8 +299,10 @@ export function mountSidebarEntry(options: SidebarEntryOptions): () => void {
   // row permanently highlighted — delete the attribute instead.
   const unsubscribeActive = options.active === undefined ? undefined : (() => {
     const syncActive = (): void => {
-      if (options.active!.isOpen()) entry.dataset.active = 'true'
+      const open = options.active!.isOpen()
+      if (open) entry.dataset.active = 'true'
       else delete entry.dataset.active
+      setOpen(open)
     }
     const unsubscribe = options.active.subscribe(syncActive)
     syncActive()