@askdkc/dsh-cli 0.11.7 → 0.12.0

package/node_modules/dsh-working-activity/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "@askdkc/dsh-working-activity",
+  "description": "Live model working-status line: playful copy, running tool, turn elapsed — for TUI prompt and Web UI",
+  "version": "0.5.0-input.0",
+  "type": "module",
+  "main": "lib/types/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/types/index.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./config": {
+      "types": "./lib/types/config.d.ts",
+      "default": "./lib/types/config.js"
+    },
+    "./events": {
+      "types": "./lib/types/events.d.ts",
+      "default": "./lib/types/events.js"
+    },
+    "./frames": {
+      "types": "./lib/types/frames.d.ts",
+      "default": "./lib/types/frames.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/types/invariant.js"
+    },
+    "./status": {
+      "types": "./lib/types/status.d.ts",
+      "default": "./lib/types/status.js"
+    },
+    "./lang": {
+      "types": "./lib/types/lang.d.ts",
+      "default": "./lib/types/lang.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "src",
+    "cordis.patch.yml"
+  ],
+  "engines": {
+    "node": "^22.19 || >=24"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/copy-client.mjs"
+  },
+  "license": "BSD-3-Clause",
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-session",
+        "@deepseek-ai/dsh-client-ui-slots"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "^0.1.0-rc.6 || ^0.1.1-rc.1 || ^0.1.2-alpha.2 || ^0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-ui-session": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.6 || ^0.1.1-rc.1 || ^0.1.2-alpha.2 || ^0.1.7-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.6 || ^0.1.1-rc.1 || ^0.1.2-alpha.2 || ^0.1.7-rc.2",
+    "@deepseek-ai/dsh-session-projection": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.6 || ^0.1.1-rc.1 || ^0.1.2-alpha.2 || ^0.1.7-rc.2",
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "react": "^18.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-client-ui-conversation": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-renderer": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-session": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-slots": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session-projection": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  }
+}

package/node_modules/dsh-working-activity/src/activity-event.ts

@@ -0,0 +1,106 @@
+/**
+ * The tracker's own event vocabulary — the only input `ActivityTracker`
+ * understands.
+ *
+ * Why this exists: the state machine used to consume raw DSH `SessionEvent`s,
+ * so every host payload drift silently changed the rendered status (the
+ * current host moved a tool-call id out of `content[]` and replaced the durable
+ * `assistant/chunk` stream with transient frames — both broke the line without
+ * a single failing test). Events here carry **meaning**, never host shape:
+ * `kind` plus already-normalized values, and every one of them is timestamped
+ * by the producer so the clock stays injectable.
+ *
+ * Producers live in `src/compat/*` (durable session events) and
+ * `src/compat/assistant-stream.ts` (live attempt frames). The tracker must
+ * never import a DSH type.
+ * @module @deepseek-ai/dsh-working-activity/activity-event
+ */
+
+/** Token counters reported by one settled assistant message. */
+export interface ActivityUsage {
+  readonly inputTokens: number
+  readonly outputTokens: number
+  readonly cacheReadTokens?: number
+  readonly cacheWriteTokens?: number
+}
+
+/** Which stream a delta came from (reasoning and text both drive narration). */
+export type ActivityStreamKind = 'text' | 'reasoning'
+
+/**
+ * Why the model is not making progress even though the turn is open: the
+ * provider asked for a retry, a tool is parked on the user's approval, or the
+ * host is compacting the context. Without this the line cannot tell "waiting
+ * on the model" from "the model is waiting on YOU".
+ */
+export type WaitingReason = 'retry' | 'approval' | 'compaction'
+
+/**
+ * Why provisional stream state was dropped: the attempt was abandoned (its
+ * output will never be settled) or only a partial settlement was committed
+ * (`assistant/attempt`). Both clear the buffer; they are not the same event.
+ */
+export type ActivityStreamResetReason = 'abandoned' | 'attempt-settled'
+
+/** One normalized activity event. */
+export type ActivityEvent =
+  /** Accepted human text from the durable session log. */
+  | { readonly kind: 'user-prompt'; readonly at: number; readonly text: string }
+  /** A new turn opened: per-turn counters reset, phase → waiting. */
+  | { readonly kind: 'turn-start'; readonly at: number }
+  /** A step opened. Carries no phase change on its own. */
+  | { readonly kind: 'step-start'; readonly at: number }
+  /** A live model attempt opened; later deltas belong to `attemptId`. */
+  | { readonly kind: 'stream-start'; readonly at: number; readonly attemptId?: string }
+  /** One streamed delta with non-empty text. */
+  | {
+    readonly kind: 'stream-delta'
+    readonly at: number
+    readonly stream: ActivityStreamKind
+    readonly text: string
+  }
+  /** Drop provisional stream state for the attempt that just ended. */
+  | { readonly kind: 'stream-reset'; readonly at: number; readonly reason: ActivityStreamResetReason }
+  /** One assistant message settled with authoritative usage (and its text). */
+  | {
+    readonly kind: 'assistant-settled'
+    readonly at: number
+    readonly usage?: ActivityUsage
+    /**
+     * The settled message's text, when it has any.
+     *
+     * Live narration arrives on stream frames, which only a live host sees; a
+     * projection (or a replayed log) folds durable events alone, so the same
+     * `⏵` line must be recoverable from the message that carries it.
+     */
+    readonly text?: string
+  }
+  /** A tool started running. */
+  | {
+    readonly kind: 'tool-start'
+    readonly at: number
+    readonly callId: string
+    readonly name: string
+    readonly arguments: string
+  }
+  /** A tool settled; `callId` is the exact id its start carried. */
+  | { readonly kind: 'tool-end'; readonly at: number; readonly callId: string; readonly failed: boolean }
+  /** The model route changed to `model`. */
+  | { readonly kind: 'route-change'; readonly at: number; readonly model: string }
+  /** Context compaction finished, or overflowed while trying. */
+  | { readonly kind: 'compaction'; readonly at: number; readonly overflow?: boolean }
+  /**
+   * The turn is stalled for `reason`. Stays until the stall resolves: a delta
+   * (the model is producing again), an approval decision, the compaction
+   * settling, or the turn closing.
+   */
+  | { readonly kind: 'waiting-reason'; readonly at: number; readonly reason: WaitingReason }
+  /** A stall resolved (e.g. `approval/decided`): back to the normal pools. */
+  | { readonly kind: 'waiting-cleared'; readonly at: number }
+  /** The agent entered another lifecycle status. */
+  | { readonly kind: 'agent-status'; readonly at: number; readonly status: 'idle' | 'running' }
+  /**
+   * The turn closed. `interrupted` is already derived by the producer from the
+   * host's reason vocabulary, so the tracker never learns those spellings.
+   */
+  | { readonly kind: 'turn-end'; readonly at: number; readonly interrupted?: boolean }

package/node_modules/dsh-working-activity/src/client/WorkingLine.module.css

@@ -0,0 +1,74 @@
+/* Working line row: one dim line with a phase-colored breathing marker and
+   the turn's tool-count badge, sized to the composer dock inset like the
+   queue strip. Mirrors the pre-slots patch's WorkingLine visuals, re-targeted
+   at the rc.6 design tokens. */
+
+.line {
+  box-sizing: border-box;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  width: 100%;
+  max-width: var(--dsh-composer-card-max-width);
+  margin: 0 auto;
+  padding: 4px 16px 0;
+  font-family: var(--dsw-font-family);
+  font-size: 13px;
+  line-height: 18px;
+  color: var(--dsw-alias-label-secondary);
+}
+
+.marker {
+  flex: none;
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: var(--dsw-alias-label-tertiary);
+  animation: working-pulse 1.6s ease-in-out infinite;
+}
+
+/* The model's turn is done: steady marker in the brand tone, no pulse. */
+.line[data-activity-phase='done'] .marker {
+  background: var(--dsw-alias-state-business-primary);
+  animation: none;
+}
+
+/* A tool is actually executing: brand-tone pulse. */
+.line[data-activity-phase='tool'] .marker {
+  background: var(--dsw-alias-state-business-primary);
+}
+
+/* Waiting for the first token: muted pulse. */
+.line[data-activity-phase='waiting'] .marker {
+  background: var(--dsw-alias-label-tertiary);
+  opacity: 0.6;
+}
+
+.text {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.tools {
+  flex: none;
+  min-width: 18px;
+  padding: 0 5px;
+  border-radius: 9px;
+  background: var(--dsw-alias-surface-tertiary);
+  color: var(--dsw-alias-label-secondary);
+  font-size: 11px;
+  line-height: 18px;
+  text-align: center;
+}
+
+@keyframes working-pulse {
+  0%,
+  100% {
+    opacity: 1;
+  }
+
+  50% {
+    opacity: 0.35;
+  }
+}

package/node_modules/dsh-working-activity/src/client/WorkingLine.tsx

@@ -0,0 +1,94 @@
+// Working-line dock entry: one dim full-width row above the composer card
+// showing the live working-activity line — phase-colored breathing marker,
+// the host-composed status line, and the turn's tool count badge.
+// Renders for every live phase (waiting/thinking/tool) and the done summary;
+// hides while idle or before the first frame.
+//
+// Data path: the host folds the `workingActivity` session projection and ships
+// the whole value to clients; the session standard kit's `useProjection` reads
+// it by key. Nothing is appended to the session log, and no client-runtime
+// patch is involved — the old `ConversationSnapshot.activity` transport is dead
+// on the current host line.
+//
+// The 'conversation.input.dock' SlotMap declaration lives in
+// @deepseek-ai/dsh-client-ui-conversation/client (contract/slots.ts) and the
+// `useProjection` standard seat in @deepseek-ai/dsh-client-ui-session/client;
+// this entry contributes into the slot without owning it.
+import type { PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots'
+// Type-only merges, erased at build time and never required by the bundle:
+// the ui-conversation SlotMap entry (the dock seat's owner props) and the
+// ui-session standard kit (`useProjection`). ./activity.ts carries this
+// package's own projection-key merge, the key constant, and the view type.
+import type {} from '@deepseek-ai/dsh-client-ui-conversation/client'
+import type {} from '@deepseek-ai/dsh-client-ui-session/client'
+import { ACTIVITY_PROJECTION_KEY, type WorkingActivityView } from './activity.ts'
+import { refreshElapsedSuffix } from './elapsed.js'
+import css from './WorkingLine.module.css'
+
+/** Full props of the dock entry: the input-zone runtime share (session standard kit). */
+export type WorkingLineProps = PropsRuntime<'conversation.input.dock'>
+
+/** Tool-count badge copy (no locale seat: the line text itself is host-composed). */
+const TOOLS_LABEL = 'tools this turn'
+
+/** The one live tick attachment (exactly one dock row exists at a time). */
+let tickAttachment: { readonly el: HTMLElement; readonly timer: ReturnType<typeof setInterval> } | undefined
+
+/**
+ * Re-tick the elapsed counter on the mounted text node, once per second.
+ *
+ * The projection only pushes when a committed event folds (measured: three
+ * pushes per turn), so the host-rendered `line` ages between folds — the
+ * elapsed text would freeze for the length of a tool. The row therefore
+ * re-ticks the ONE moving segment locally; only segments matching the host's
+ * elapsed shapes are ever replaced (see ./elapsed.ts).
+ *
+ * Imperative on purpose, and hook-free: the component is also invoked as a
+ * plain function (the bundle gate reads its tree without a renderer), and a
+ * ref callback plus this module-level slot is enough — React detaches a
+ * changed inline ref with `null` first, which is where the previous interval
+ * dies; a settled value simply never attaches a new one.
+ */
+function attachElapsedTick(el: HTMLElement | null, activity: WorkingActivityView | undefined): void {
+  if (tickAttachment !== undefined && (el === null || tickAttachment.el !== el)) {
+    clearInterval(tickAttachment.timer)
+    tickAttachment = undefined
+  }
+  if (el === null || activity === undefined || activity.live !== true) return
+  const paint = (): void => {
+    el.textContent = refreshElapsedSuffix(activity.line, activity, Date.now())
+  }
+  paint()
+  tickAttachment = { el, timer: setInterval(paint, 1000) }
+}
+
+/**
+ * Working-line dock entry: reads the session's latest `workingActivity`
+ * projection value and renders the row, or nothing when idle/absent.
+ */
+export function WorkingLine({ useProjection }: WorkingLineProps) {
+  // `undefined` is the uniform absence signal: the host unit is unmounted, no
+  // frame carried the key for this session yet, or no session is current.
+  // Rendering nothing (rather than an empty row) keeps the dock from reserving
+  // space ahead of the first committed event.
+  //
+  // The annotation is load-bearing: `useProjection`'s precise engine type lives
+  // in the session kit's own dependency (`@deepseek-ai/dsh-api-session-controller`),
+  // which this package deliberately does not install (it would drag the whole
+  // client peer closure into the dev tree). The key is pinned in ./activity.ts
+  // against the merged table; this keeps the render body checked against the
+  // host's view type.
+  const activity: WorkingActivityView | undefined = useProjection(ACTIVITY_PROJECTION_KEY)
+  if (activity === undefined || activity.phase === 'idle' || activity.line === '') return null
+  return (
+    <div className={css.line} data-activity-phase={activity.phase}>
+      <span className={css.marker} aria-hidden="true" />
+      <span className={css.text} ref={el => attachElapsedTick(el, activity)}>{activity.line}</span>
+      {activity.toolCount > 0 && (
+        <span className={css.tools} title={`${activity.toolCount} ${TOOLS_LABEL}`}>
+          {activity.toolCount}
+        </span>
+      )}
+    </div>
+  )
+}

package/node_modules/dsh-working-activity/src/client/activity.ts

@@ -0,0 +1,43 @@
+/**
+ * Client-side contract of the working-activity Web half: the `workingActivity`
+ * key of the session-projection type table.
+ *
+ * The browser reads the line through the session standard kit's
+ * `useProjection('workingActivity')` — the host folds the projection from
+ * committed session events and ships the whole value, so no client-side domain
+ * folding exists and nothing is appended to the session log.
+ *
+ * The runtime patch that used to carry the value on the conversation snapshot
+ * (`ConversationSnapshot.activity`, declared against `@deepseek-ai/dsh-client-runtime`)
+ * is obsolete for the current host line: that package is frozen at `0.1.1-rc.2`
+ * and absent from the `0.1.7-rc.2` client cohort.
+ *
+ * {@link WorkingActivityView} is imported from the host half on purpose — one
+ * definition of the wire value, so the two halves cannot drift. The import is
+ * TYPE-ONLY: a value import would pull host-only code (zod, node builtins) into
+ * the browser bundle, which the build's purity gate rejects.
+ * @module @deepseek-ai/dsh-working-activity/client/activity
+ */
+
+import type { SessionProjectionMap } from '@deepseek-ai/dsh-session-projection/types'
+import type { WorkingActivityView } from '../projection.js'
+
+declare module '@deepseek-ai/dsh-session-projection/types' {
+  interface SessionProjectionMap {
+    /**
+     * Latest folded working line for the current session, or absent while the
+     * host unit is unmounted or no committed event has folded yet.
+     */
+    workingActivity: WorkingActivityView
+  }
+}
+
+/**
+ * The projection key this package reads, checked against the merged table: a
+ * rename on the host side, or a merge that silently failed to land, is a
+ * compile error here instead of a dock row that never renders.
+ */
+export const ACTIVITY_PROJECTION_KEY =
+  'workingActivity' satisfies Extract<keyof SessionProjectionMap, string>
+
+export type { WorkingActivityView }

package/node_modules/dsh-working-activity/src/client/css-modules.d.ts

@@ -0,0 +1,6 @@
+/* CSS Modules ambient declaration for the client half (tsc only; the tsdown
+   bundle inlines compiled class maps). */
+declare module '*.module.css' {
+  const classes: Readonly<Record<string, string>>
+  export default classes
+}

package/node_modules/dsh-working-activity/src/client/elapsed.ts

@@ -0,0 +1,88 @@
+/**
+ * Client-side elapsed re-tick for the working line.
+ *
+ * The projection is event-driven: the host pushes a value when a committed
+ * event folds, and `view` renders at read time. The TUI creates its own
+ * cadence by re-reading; a browser cannot, so between folds the shipped
+ * `line` ages — measured on the rc.2 corridor, one turn carried three
+ * pushes, freezing the elapsed text for the length of a tool. While `live`
+ * is true, the dock row therefore re-ticks the ONE moving segment locally:
+ * the elapsed counter.
+ *
+ * Safety: a segment is replaced only when it matches the shapes the host
+ * emits (`总1m23s` / `total 5s` / a bare `87ms`). Any format drift on the
+ * host side makes the matcher miss and the row falls back to the host's
+ * (aging) text — stale, but never wrong. Settled `✓` lines carry a fixed
+ * duration, not a counter, and are left alone. This module is deliberately
+ * dependency-free: the host's `phrases.ts` reaches node builtins for
+ * language detection, which the client bundle's purity gate rejects.
+ * @module @deepseek-ai/dsh-working-activity/client/elapsed
+ */
+
+/** What the caller knows about the value whose line is displayed. */
+export interface ElapsedTickView {
+  /** Current phase; only live phases carry a moving counter. */
+  readonly phase: 'idle' | 'waiting' | 'thinking' | 'tool' | 'done'
+  /** Wall clock the current phase began (the tool counter counts from it). */
+  readonly phaseStartedAt: number
+  /** Wall clock the current turn began (the elapsed counter counts from it). */
+  readonly turnStartedAt: number
+  /** Language the host rendered `line` in. */
+  readonly lang: 'zh' | 'en'
+}
+
+/** The duration shapes the host emits: `87ms`, `5s`, `1m23s`, `4h0m`. */
+const DURATION = /^\d+(?:ms|s|m\d+s|h\d+m)$/
+/** The localized elapsed segment: `总5s`, `total 1m23s`. */
+const ELAPSED = /^(?:总|total )\d+(?:ms|s|m\d+s|h\d+m)$/
+/** The segment separator the host composes the line with. */
+const SEP = ' · '
+
+/** Mirror of the host's `fmtDuration` (second granularity and shapes). */
+function formatDuration(ms: number): string {
+  if (ms < 1000) return '0s'
+  const total = Math.floor(ms / 1000)
+  if (total < 60) return `${total}s`
+  const minutes = Math.floor(total / 60)
+  const seconds = total % 60
+  if (minutes < 60) return `${minutes}m${seconds}s`
+  return `${Math.floor(minutes / 60)}h${minutes % 60}m`
+}
+
+/** Mirror of the host's `durationLabel` (sub-second reads in milliseconds). */
+function formatCounter(ms: number): string {
+  return ms < 1000 ? `${Math.max(0, Math.floor(ms))}ms` : formatDuration(ms)
+}
+
+/**
+ * Replace the line's elapsed segment with one computed at `nowMs`.
+ *
+ * @param line - The host-rendered line (aged to the last fold).
+ * @param view - The value's phase, counters and language.
+ * @param nowMs - Wall clock to re-tick to.
+ * @returns the line with a current counter, or the input when there is
+ * nothing safe to replace.
+ */
+export function refreshElapsedSuffix(line: string, view: ElapsedTickView, nowMs: number): string {
+  if (view.phase === 'idle' || view.phase === 'done') return line
+  // A settled tool's `✓ … · 887ms` is a fixed fact, not a counter.
+  if (line.startsWith('✓ ')) return line
+  // The tool counter counts from the phase's entry; with concurrent tools the
+  // host's own counter tracks the OLDEST one, so this may trail it by the
+  // overlap — a display nuance, not a wrong number.
+  const since = view.phase === 'tool' ? view.phaseStartedAt : view.turnStartedAt
+  if (!(since > 0)) return line
+  const elapsed = Math.max(0, nowMs - since)
+  const replacement = view.phase === 'tool'
+    ? formatCounter(elapsed)
+    : (view.lang === 'en' ? `total ${formatDuration(elapsed)}` : `总${formatDuration(elapsed)}`)
+  const segments = line.split(SEP)
+  for (let i = segments.length - 1; i > 0; i--) {
+    const segment = segments[i]
+    if (segment !== undefined && (DURATION.test(segment) || ELAPSED.test(segment))) {
+      segments[i] = replacement
+      return segments.join(SEP)
+    }
+  }
+  return line
+}

package/node_modules/dsh-working-activity/src/client/index.ts

@@ -0,0 +1,45 @@
+/**
+ * Working-activity surface plugin, browser half: the working-line entry in
+ * the conversation.input.dock strip.
+ *
+ * The node half folds every committed session event into the `workingActivity`
+ * session projection and the host ships that value to clients; this dock entry
+ * reads it through the session standard kit's `useProjection` and owns no
+ * store, no refresh chain, and no event listener. Nothing is appended to the
+ * session log — the reason dsh-tui mounts this plugin with `publish: false`.
+ *
+ * Mount contract (see the root README's "Web UI 集成" section): the web
+ * client's client-modules host scans loader entries for `dsh.client`
+ * declarations and serves this package's `./client` bundle at
+ * /plugins/dsh-working-activity/client.js. The entry contributes into the
+ * input dock — no official-source patch is involved.
+ */
+import type { Context } from '@deepseek-ai/cordis'
+// Type-only merges: the ui-conversation SlotMap entry (the dock seat) and the
+// ui-renderer `slots` service on the client Context. Both are erased at build
+// time and never required by the bundle.
+import type {} from '@deepseek-ai/dsh-client-ui-conversation/client'
+import type {} from '@deepseek-ai/dsh-client-ui-renderer/client'
+import { WorkingLine } from './WorkingLine.tsx'
+
+export { WorkingLine, type WorkingLineProps } from './WorkingLine.tsx'
+export type { WorkingActivityView } from './activity.ts'
+
+/** Required services for the dock registration. */
+export const inject = ['slots']
+
+/**
+ * Client plugin body: the working-line dock entry.
+ * @param ctx - client root context.
+ */
+export function apply(ctx: Context): void {
+  ctx.slots.inject('conversation.input.dock', () => ctx.slots.register({
+    name: 'conversation.input.dock',
+    // The pre-slots patch used the same id in ui-conversation; entries with
+    // equal order render in registration order, and goal (10) / queue (20)
+    // keep their seats — this row sits between them.
+    id: 'activity',
+    order: 15,
+    registrant: 'dsh-working-activity',
+  }, WorkingLine))
+}