@linxin666/dsh-client-ui-task-board 0.4.2 → 0.4.3

package/lib/types/host-ledger.d.ts

@@ -116,6 +116,15 @@ export declare class HostTaskLedger {
     runtimeView(): LedgerRuntimeView;
     /** Count armed, non-archived schedules without cloning task histories. */
     armedScheduleCount(): number;
+    /**
+     * The earliest armed `nextRunAt` strictly after the supplied Host time, or
+     * undefined when no schedule is armed in the future. This is the instant the
+     * Host arms its native timer at, so the board wakes exactly when work is due
+     * instead of polling a fixed heartbeat.
+     * @param now - current Host time in ms epoch.
+     * @returns the nearest future trigger, or undefined when none is armed.
+     */
+    nextArmedRunAt(now: number): number | undefined;
     /** Return value-only references for schedules due at the supplied Host time. */
     dueSchedules(now: number): DueScheduleReference[];
     subscribe(listener: () => void): () => void;

package/lib/types/host-service.d.ts

@@ -31,16 +31,30 @@ export interface TeamSpawnResult {
 export interface TaskBoardTeamDispatcher {
     spawn(input: TeamSpawnInput): Promise<TeamSpawnResult>;
 }
+/**
+ * The native timer face the Host arms through. The cordis `timer` service
+ * (dsh-base's own `cordis-plugin-timer` row) provides it: its handles are
+ * registered on the owning fiber, so unloading the board clears every armed
+ * timer without this service tracking handles by hand. A composition that
+ * serves no timer service falls back to the process globals.
+ */
+export interface HostTimerFace {
+    timeout(callback: () => void, delay: number): () => void;
+    interval(callback: () => void, delay: number): () => void;
+}
 export declare class TaskBoardHostService {
     readonly ledger: HostTaskLedger;
     readonly runner: HostExecutionRunner;
     readonly power: PowerInhibitor;
     private readonly listeners;
-    private timers;
-    private lastScheduleTick;
+    /** The one recurring timer: the session-roster poll. */
+    private pollTimer;
+    /** The armed schedule timer, if a trigger is pending. */
+    private scheduleTimer;
+    /** The instant the armed schedule timer targets (ms epoch), for resume detection. */
+    private scheduleTarget;
     private disposed;
     private pollInFlight;
-    private tickInFlight;
     private active;
     /**
      * Ids the last roster poll saw as present and idle; undefined while the
@@ -51,6 +65,7 @@ export declare class TaskBoardHostService {
     private idleSessionIds;
     private preventIdleSleep;
     private readonly team;
+    private readonly timers;
     private lastPowerJson;
     private readonly now;
     constructor(gateway: TypertGateway, options?: {
@@ -62,6 +77,7 @@ export declare class TaskBoardHostService {
         sessionDefaultPermission?: TaskPermission;
         maxSubtaskDepth?: number;
         team?: TaskBoardTeamDispatcher;
+        timers?: HostTimerFace;
     });
     start(): void;
     setConfiguration(active: boolean, preventIdleSleep: boolean): void;
@@ -84,7 +100,32 @@ export declare class TaskBoardHostService {
     private pollSessions;
     /** Reuse the session list this poll already fetched: one list RPC per tick, not 1 + E. */
     private reconcileExecutions;
-    private tickSchedule;
+    /** Drop the armed schedule timer and forget its target. */
+    private clearScheduleTimer;
+    /**
+     * Boot / resume recovery: skip every occurrence that came due while the
+     * board was not running and roll each schedule to its next future target,
+     * then arm the timer for the nearest one. Rendering the occurrence is
+     * deliberately not attempted: the ACL of a card that fired hours ago is
+     * stale, and the board's own recovery contract is "missed triggers are
+     * skipped, never replayed".
+     */
+    private recoverSchedule;
+    /**
+     * Arm the native timer at the nearest armed future trigger. One timer serves
+     * every schedule: the ledger's next target is the only instant the Host has
+     * to wake for. A target beyond the platform's timer ceiling re-arms in
+     * segments, and a target already past (the wall clock jumped, or the process
+     * was suspended) is handled immediately as a recovery.
+     */
+    private armSchedule;
+    /**
+     * One armed target became due. A fire landing well past its target is a
+     * resume (suspend, throttle, forward clock jump) rather than a normal
+     * occurrence, so it takes the recovery path instead of launching a run for a
+     * long-stale instant.
+     */
+    private onScheduleFire;
     private armedSchedules;
     /**
      * Launch one run set. The root goes first and receives the run shape in its
@@ -96,7 +137,12 @@ export declare class TaskBoardHostService {
     private dispatchRuns;
     private scheduleLaunch;
     private schedulePoll;
-    private scheduleTick;
+    /**
+     * Re-arm from the ledger's current targets. Callers that just changed a
+     * schedule (the host routes, the agent tools) invoke this after the write
+     * commits, so a new or edited trigger arms without waiting for the next fire.
+     */
+    refreshSchedule(): void;
     private syncPowerReasons;
     private emit;
 }

package/lib/types/index.d.ts

@@ -9,7 +9,7 @@ import type { Context, Volatile } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
 import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
 import type { LlmRuntime } from '@deepseek-ai/dsh-llm';
-import { type TaskBoardTeamDispatcher } from './host-service.ts';
+import { type HostTimerFace, type TaskBoardTeamDispatcher } from './host-service.ts';
 import { type TaskPermission } from './core/tasks.ts';
 /** Default environment variable holding the authenticated proxy token. */
 export declare const DEFAULT_PROXY_TOKEN_ENV = "DSH_TASK_BOARD_PROXY_TOKEN";
@@ -139,6 +139,16 @@ interface AgentToolRegistry {
  * @returns the registry, or undefined when this deployment serves none.
  */
 export declare function resolveToolRegistry(ctx: Context): AgentToolRegistry | undefined;
+/**
+ * Resolve the native cordis timer service (dsh-base's own `cordis-plugin-timer`
+ * row). The board arms its schedule through it so unloading the row clears
+ * every pending timer with the owning fiber, instead of the row tracking raw
+ * process handles by hand. A composition that serves no timer service keeps
+ * working on the process globals.
+ * @param ctx - the plugin context.
+ * @returns the timer face, or undefined when this deployment serves none.
+ */
+export declare function resolveHostTimers(ctx: Context): HostTimerFace | undefined;
 /** The subset of the Agent Teams service this plugin drives. */
 interface AgentTeamsFace {
     spawnTeammate(caller: unknown, request: {

package/lib/types/mount-once.d.ts

@@ -4,19 +4,50 @@
  * the loader accepts a standalone install of the same package side by side;
  * without this guard the second instance would still re-register the same
  * webserver routes, tools, settings namespaces, and system-prompt sections
- * and fail the boot. mountOnce makes the second host apply a no-op for the
- * lifetime of the first instance (the browser half is already deduped by
- * package name in the client module host).
+ * and fail the boot. mountOnce makes a mount of an already-mounted package a
+ * no-op for as long as the first instance lives (the browser half is already
+ * deduped by package name in the client module host).
+ *
+ * A no-op is only safe while the holder is ALIVE. The holder can be disposed
+ * long after the refused mount ran its course: the Host reloads a profile by
+ * creating the new loader entries before the old ones are torn down (a
+ * plugin-manager enable/disable/install write, a settings-driven row reload,
+ * HMR), so the new aggregate shell entry mounts its family plugin while the
+ * previous entry still owns the name. Dropping that refused mount lost the
+ * plugin for good - the previous entry then disposed its own mount, releasing
+ * the name with nobody left to take it, and the family row stayed listed as
+ * active while its host routes 404ed (the task-board panel showed
+ * "board.hostError.notMounted", no degraded record appeared, and only a Host
+ * restart recovered it).
+ *
+ * The refused mount is therefore QUEUED, not dropped, and replayed the moment
+ * the holder releases the name - if the waiting fiber is still alive then. The
+ * single-instance guarantee is unchanged: exactly one mount is live per
+ * package name, and the replay re-enters the guard so a later mount still
+ * dedupes against it.
  *
  * The registry rides a global symbol so two module instances of the same
- * package (npm copy vs repository link) still share one verdict. cordis
- * `ctx.effect` runs its callback immediately and treats the callback's
+ * package (npm copy vs repository link) still share one verdict. That symbol
+ * is a CROSS-REPOSITORY contract, not this file's private state: the four
+ * satellite packages (dsh-skins / dsh-pet / dsh-presets /
+ * dsh-community-plugins) are separate repositories carrying their own copy of
+ * this guard, rebuilt on their own schedule, so the value under `MOUNTED`
+ * must keep the shape every published copy reads (a `Set` of package names
+ * with `has`/`add`/`delete`). The wait queues this guard added therefore live
+ * under their own additive key, and the registry reads back a `Set` even when
+ * some other build left a different value there. Changing `MOUNTED`'s shape
+ * in place broke that contract once: a satellite's legacy copy created a
+ * `Set`, the family's new copy read it as a `Map`, and every family row
+ * mounted after it failed with "claims.get is not a function".
+ *
+ * cordis `ctx.effect` runs its callback immediately and treats the callback's
  * return value as the fiber disposer, so the unmarker is returned, not run.
  */
 /**
  * Wrap a cordis plugin apply so the package runs at most once per process.
- * The first mount registers normally and unmarks when its fiber disposes;
- * any later mount of the same package name is a no-op.
+ * The first mount registers normally and releases the name when its fiber
+ * disposes; a mount refused while that name is held waits for the release and
+ * then runs, unless its own fiber disposes first.
  * @param packageName - npm package identity shared by every install source.
  * @param fn - the original plugin apply.
  * @returns an apply of the same shape.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@linxin666/dsh-client-ui-task-board",
   "description": "Host-authoritative task board for the DSH Web GUI with real session execution, Host cron scheduling, and optional cross-platform idle-sleep protection; mounted without DSH source changes.",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "icon": "icon.svg",
   "type": "module",
   "main": "lib/index.js",
@@ -34,6 +34,7 @@
         "@deepseek-ai/dsh-client-connection",
         "@deepseek-ai/dsh-client-ui-settings",
         "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-layout",
         "@deepseek-ai/dsh-api-session-controller",
         "@deepseek-ai/dsh-api-workspace-controller",
         "@deepseek-ai/dsh-api-remotes",
@@ -60,8 +61,10 @@
     "@deepseek-ai/dsh-client-connection": "^0.1.7-rc.2",
     "@deepseek-ai/dsh-client-locale": "^0.1.7-rc.2",
     "@deepseek-ai/dsh-client-store": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-ui-layout": "^0.1.7-rc.2",
     "@deepseek-ai/dsh-client-ui-renderer": "^0.1.7-rc.2",
     "@deepseek-ai/dsh-client-ui-settings": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-ui-sidebar": "^0.1.7-rc.2",
     "@deepseek-ai/dsh-client-ui-slots": "^0.1.7-rc.2",
     "@deepseek-ai/dsh-client-ui-workspace": "^0.1.7-rc.2",
     "@deepseek-ai/dsh-commands": "^0.1.7-rc.2",

package/src/client/board.module.css

@@ -4,135 +4,30 @@
  * board follows the active theme (light/dark and skins).
  */
 
-/* --- center-column takeover (global rules, attribute-scoped) ----------------- */
+/* --- native panel page ------------------------------------------------------- */
 
-[data-pane='conversation'],
-[class*='centerCol'] {
-  position: relative;
-}
+/* The board is an official center-column panel: the layout mounts this element
+   as the selected keyed 'main' occupant, so the shell's own column already
+   owns position, sizing and the conversation underneath. Nothing here hides or
+   re-parents another plugin's surface — the previous DOM takeover (absolute
+   overlay over a hidden conversation subtree) is gone with it.
 
-/* The board container rides inside the conversation grid item as an extra
-   trailing child; hidden unless the board is active. */
+   The container query context stays: the board's responsive rules measure the
+   PANEL rather than the viewport, so a narrow column or a resized window
+   narrows the board at the same threshold the shell uses for its columns. */
 [data-dsh-taskboard-view] {
-  position: absolute;
-  inset: 0;
-  display: none;
-  z-index: 60;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+  width: 100%;
+  height: 100%;
+  min-width: 0;
+  min-height: 0;
   container-name: task-board-view;
   container-type: inline-size;
-  /* Opaque backdrop: the conversation subtree stays mounted under the view.
-     Even if the hide rule below were defeated by a stronger host inline
-     style, this background keeps sticky code-block banners (host z-index 6)
-     from showing through the active board (issue #100). */
   background: var(--dsw-alias-bg-base);
 }
 
-/* The center column is single-occupant; the :not() guards keep the two
-   sibling panels (task board / ssh) from fighting over visibility if both
-   activation attributes ever coexist. */
-html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [data-dsh-taskboard-view] {
-  display: block;
-}
-
-/* While the board is active, the conversation content underneath is hidden
-   (it stays mounted and stateful). The !important is required: the dsh shell
-   (0.1.0-rc.6) wraps the conversation view in a node with an inline
-   `display: contents`, and inline styles beat a plain stylesheet rule. Without
-   it the composer (input card) stays visible at the bottom and paints over the
-   board modals' footer, hiding the run/delete buttons (issue #76).
-   The rule targets both the pane attribute and the center-column class so the
-   chat subtree (including the code-block copy banner, issue #100) stays hidden
-   whichever host container carries it. */
-html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [data-pane='conversation'] > :not([data-dsh-taskboard-view]),
-html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol'] > :not([data-dsh-taskboard-view]) {
-  display: none !important;
-}
-
-/* --- sidebar entry row ------------------------------------------------------- */
-
-/* Same geometry as the shell's own panel rows (SidebarRoot .panelRow): 2px
-   inset with a 12px radius, 8px content padding, 36px row, 14/22 type, and the
-   primary ink — so an injected row and an official row line up column for
-   column instead of each carrying its own box. */
-.entry {
-  box-sizing: border-box;
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  min-height: 36px;
-  padding: 7px 8px;
-  margin: 0 2px;
-  background: transparent;
-  border: none;
-  border-radius: 12px;
-  color: var(--dsw-alias-label-primary);
-  cursor: pointer;
-  font: inherit;
-  font-size: 14px;
-  line-height: 22px;
-  text-align: left;
-  white-space: nowrap;
-}
-
-.entry:hover {
-  background: var(--dsw-alias-interactive-bg-hover);
-  color: var(--dsw-alias-label-primary);
-}
-
-.entry[data-active] {
-  background: var(--dsw-alias-interactive-bg-active);
-  color: var(--dsw-alias-label-primary);
-  font-weight: 600;
-}
-
-/* Icon box matches the shell's panel glyph exactly (16px), so the glyph column
-   and the label column land on the official rows' x positions. */
-.entryIcon {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  width: 16px;
-  height: 16px;
-  flex: none;
-}
-
-.entryIcon svg {
-  display: block;
-  width: 16px;
-  height: 16px;
-}
-
-.entryLabel {
-  overflow: hidden;
-  text-overflow: ellipsis;
-}
-
-/* Collapsed rail: icon-only, centered, matching the shell's 56px rail. The
-   shell asks its own panel rows for an 18px glyph on the rail, so the icon box
-   and the svg step up together with the 12px rail radius. */
-:global([data-dsh-frame][data-sidebar-collapsed]) .entry,
-:global([data-sidebar-collapsed]) .entry {
-  justify-content: center;
-  padding: 0;
-  width: 36px;
-  height: 36px;
-  margin: 0 auto 12px;
-  border-radius: 12px;
-}
-
-:global([data-dsh-frame][data-sidebar-collapsed]) .entryIcon,
-:global([data-sidebar-collapsed]) .entryIcon,
-:global([data-dsh-frame][data-sidebar-collapsed]) .entryIcon svg,
-:global([data-sidebar-collapsed]) .entryIcon svg {
-  width: 18px;
-  height: 18px;
-}
-
-:global([data-dsh-frame][data-sidebar-collapsed]) .entryLabel,
-:global([data-sidebar-collapsed]) .entryLabel {
-  display: none;
-}
-
 /* --- board frame -------------------------------------------------------------- */
 
 .board {
@@ -924,7 +819,6 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
     height: 100dvh;
   }
 
-  .entry,
   .card,
   .primaryButton,
   .ghostButton,
@@ -1038,7 +932,6 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
  * --------------------------------------------------------------------------- */
 
 /* --- one themed focus-visible ring (approx 2px, 2px offset) --- */
-.entry:focus-visible,
 .card:focus-visible,
 .primaryButton:focus-visible,
 .ghostButton:focus-visible,
@@ -1055,7 +948,6 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
 }
 
 /* --- unified 120ms motion across the board's interactive controls --- */
-.entry,
 .primaryButton,
 .ghostButton,
 .dangerButton,
@@ -1075,7 +967,6 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
   transform: translateY(0);
 }
 
-.entry:active,
 .primaryButton:active:not(:disabled),
 .ghostButton:active:not(:disabled),
 .dangerButton:active:not(:disabled),
@@ -1084,11 +975,6 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
   transform: translateY(1px);
 }
 
-/* --- entry row (sidebar) states --- */
-.entry[data-active]:hover {
-  background: var(--dsw-specific-sidebar-nav-item-active);
-}
-
 /* --- guarded hover for the remaining icon/link buttons (defensive: never
        disabled today, but a disabled element must not react to hover) --- */
 .iconButton:hover:not(:disabled) {
@@ -1121,7 +1007,6 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
 
 /* --- reduced motion: strip transitions, stop the decorative spinner --- */
 @media (prefers-reduced-motion: reduce) {
-  .entry,
   .card,
   .primaryButton,
   .ghostButton,

package/src/client/index.ts

@@ -24,17 +24,17 @@ import type {} from '@deepseek-ai/dsh-client-ui-settings/client'
 // Type-only: pulls the workspace plugin's Context merge (ctx.uiWorkspace), the
 // multi-instance navigation face that replaced ISessions.open().
 import type {} from '@deepseek-ai/dsh-client-ui-workspace/client'
-import { BoardController } from '../core/controller.ts'
+import { BoardController, TASK_BOARD_PANEL_ID } from '../core/controller.ts'
 import { mainViewSessionId } from './main-session.ts'
 import { LocalStorageTaskStore } from '../core/store.ts'
 import { claimTaskboardApply, releaseTaskboardApply } from './apply-guard.ts'
-import { mountBoard } from './board-mount.tsx'
-import { mountSidebarEntry } from './sidebar-entry.ts'
+import { registerTaskBoardPanel } from './native-panel.tsx'
 import { TaskBoardSettingsCard, TaskBoardSettingsCardController, type TaskBoardSettings } from './TaskBoardSettingsCard.tsx'
 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'
+import { createServedEntryForm } from './settings-entry-form.ts'
 
 /** Locale namespace this plugin owns. */
 const NS = 'task-board'
@@ -124,7 +124,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', 'configForms', 'locale', 'remote', 'remote.session', 'uiWorkspace']
+export const inject = ['slots', 'sessions', 'workspaces', 'connection', 'configForms', 'locale', 'remote', 'remote.session', 'uiWorkspace', 'layout']
 
 /** One agent-preset row the mode picker consumes (either face's wire shape). */
 interface PresetRosterRow {
@@ -241,6 +241,18 @@ export function apply(ctx: ClientContext): void {
     const controller = new BoardController({
       store,
       transport: new HttpTaskBoardHostTransport(),
+      // Panel navigation belongs to the layout service: the board asks it to
+      // select its own panel id (or the conversation) instead of taking over
+      // the center column at the DOM level. The lookup stays lazy so a
+      // selection issued before the service settles still lands once it does,
+      // and the face throws by contract before the layout root entry mounts,
+      // which the controller tolerates.
+      panel: {
+        select: panelId => {
+          const layout = ctx.get('layout') as { selectPanel?: (id: string | null) => void } | undefined
+          layout?.selectPanel?.(panelId)
+        },
+      },
       sessions: {
         // The main-view Session comes from the catalog's per-source ownership
         // counts; navigation belongs to the workspace UI since the
@@ -362,12 +374,24 @@ export function apply(ctx: ClientContext): void {
     }
     void pushModelOptions()
     disposers.push(ctx.on('connection/reset', () => { void pushModelOptions() }))
+    // Native panel surfaces: one sidebar row and one center-column page, both
+    // through the official slot seats the shell itself renders. The layout's
+    // panel selection is reconciled back into the controller so the board's own
+    // view state follows the user clicking another panel row.
     try {
-      disposers.push(mountSidebarEntry(controller, ctx.locale))
-      disposers.push(mountBoard(controller, ctx.locale))
+      disposers.push(registerTaskBoardPanel(ctx, controller))
+      const layoutFace = ctx.get('layout') as { panelInfo?: { subscribe(listener: () => void): () => void; getSnapshot(): { activePanelId: unknown } } } | undefined
+      if (layoutFace?.panelInfo !== undefined) {
+        const sync = (): void => {
+          const active = layoutFace.panelInfo!.getSnapshot().activePanelId
+          controller.syncPanelSelection(active === TASK_BOARD_PANEL_ID ? TASK_BOARD_PANEL_ID : null)
+        }
+        sync()
+        disposers.push(layoutFace.panelInfo.subscribe(sync))
+      }
     } catch (error) {
-      // DOM failures degrade the board, never the GUI.
-      console.error('[dsh-task-board] mount failed:', error)
+      // A shell that cannot serve the seats degrades the board, never the GUI.
+      console.error('[dsh-task-board] panel registration failed:', error)
     }
 
     uiDisposer = () => {
@@ -415,22 +439,26 @@ export function bindSettingsForm(ctx: ClientContext): ConfigForm<TaskBoardSettin
   if (binder !== undefined && typeof binder.bind === 'function') {
     return binder.bind<TaskBoardSettings>({ namespace: TASK_BOARD_NS })
   }
-  return ctx.configForms.get<TaskBoardSettings>(servedEntryId(ctx.configForms))
+  return createServedEntryForm<TaskBoardSettings>({
+    forms: ctx.configForms,
+    entryIds: TASK_BOARD_ENTRY_IDS,
+  })
 }
 
 /**
- * The profile entry id this package's own row carries.
+ * The profile entry id this package's own row carries, for a page that serves
+ * no family binder.
  *
  * The shared describe mirror is the only local evidence of which row id this
- * profile actually serves, but it answers asynchronously: at plugin
- * activation it usually holds nothing yet. An unanswered mirror therefore
- * binds the aggregate row id rather than guessing among the candidates —
- * the form is bound once for the session, so a wrong guess would leave the
- * card reporting an unserved namespace even after the mirror settles.
+ * profile actually serves, but it answers asynchronously: at plugin activation
+ * it usually holds nothing yet. An unanswered mirror therefore binds the
+ * aggregate row id rather than guessing among the candidates, and the binding
+ * is re-resolved once the mirror answers — see
+ * {@link createServedEntryForm}, which owns that rebinding.
  * @param forms - the shared configuration forms service.
- * @returns the entry id to bind.
+ * @returns the entry id to bind before the mirror answers.
  */
-function servedEntryId(forms: ConfigForms): string {
+export function servedEntryId(forms: ConfigForms): string {
   let served: readonly string[] | undefined
   try {
     served = forms.describe().getSnapshot().view?.namespaces.map(view => view.ns)

package/src/client/native-panel.tsx

@@ -0,0 +1,124 @@
+/**
+ * Native panel registration for the task board.
+ *
+ * The board is an official-style center-column panel, not a DOM takeover: it
+ * contributes a row into the sidebar shell's own global panel list
+ * (`sidebar.panellist`) and its page into the layout's keyed `main` slot. The
+ * shell then owns the row box, the label, the active highlight, the collapsed
+ * rail, the panel switch and the window-chrome interplay exactly as it does for
+ * the shipped Plugins and Schedule pages, so the board renders through the same
+ * container the desktop application's Plugins page uses.
+ *
+ * Both registrations go through `ctx.slots.inject`, which fires only once the
+ * owning shell entry has declared the seat: load order between this plugin and
+ * ui-layout / ui-sidebar therefore does not matter, and neither does a shell
+ * that cannot serve the seats (the callback simply never runs).
+ *
+ * @module @linxin666/dsh-client-ui-task-board/client
+ */
+import type { Context as ClientContext } from '@deepseek-ai/cordis'
+import type {} from '@deepseek-ai/dsh-client-ui-slots'
+import type {} from '@deepseek-ai/dsh-client-ui-layout/client'
+import type {} from '@deepseek-ai/dsh-client-ui-sidebar/client'
+import { TASK_BOARD_PANEL_ID, type BoardController } from '../core/controller.ts'
+import { TaskBoard } from './board/TaskBoard.tsx'
+import { t } from './locales.ts'
+import css from './board.module.css'
+
+/** The panel id shared by the sidebar row and the main-slot occupant. */
+export { TASK_BOARD_PANEL_ID }
+
+/** Row order among the shell's global panel rows (Plugins is 0, Schedule 10). */
+const PANEL_ORDER = 20
+
+/**
+ * The sidebar row glyph the shell asks for at its own size and active state.
+ * The shell owns the button, label, tooltip and rail geometry; this component
+ * draws only the glyph, like every other panel row.
+ *
+ * The glyph carries `data-dsh-panel-entry` because it is the only DOM the
+ * panel's own code owns inside that shell-owned row: the L2 contract (skins)
+ * resolves which row belongs to which plugin through it, since the shell
+ * stamps no per-entry hook of its own (see contracts/semantic-attrs-v1.md).
+ * @param props - the shell's icon share: square edge and selection state.
+ * @returns the decorative board glyph.
+ */
+export function TaskBoardPanelIcon({ size }: { size: number; active: boolean }): React.ReactElement {
+  return (
+    <svg
+      data-dsh-panel-entry={TASK_BOARD_PANEL_ID}
+      viewBox="0 0 16 16"
+      width={size}
+      height={size}
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="1.3"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      aria-hidden="true"
+    >
+      <rect x="2" y="2.5" width="12" height="11" rx="1.5" />
+      <path d="M2 6.5h12M6.5 6.5v7" />
+    </svg>
+  )
+}
+
+/**
+ * The main-slot page. The layout mounts it only while the board is the selected
+ * panel, so the conversation keeps the center column untouched the rest of the
+ * time; the wrapper carries the pinned `data-dsh-taskboard-view` semantic
+ * anchor (L2 contract, skins) and the container query context the board's
+ * responsive rules read.
+ * @param props - the framework main-slot share plus this entry's injected face.
+ * @returns the board page.
+ */
+export function TaskBoardPanel({ controller }: { controller: BoardController }): React.ReactElement {
+  return (
+    <div className={css.panel} data-dsh-taskboard-view="" data-dsh-plugin="task-board">
+      <TaskBoard controller={controller} />
+    </div>
+  )
+}
+
+/** The injected face both registrations receive. */
+interface PanelFace {
+  controller: BoardController
+}
+
+/**
+ * Register the board's sidebar row and center-column page.
+ *
+ * Both seats are declared by shell plugins this package does not depend on at
+ * runtime, so each registration is wrapped in `ctx.slots.inject`: the callback
+ * runs only after the owning entry declares the seat, and a shell that never
+ * declares it leaves the board simply absent instead of failing boot.
+ * @param ctx - client root context (services: slots).
+ * @param controller - the board controller the page and the row drive.
+ * @returns disposer releasing both registrations.
+ */
+export function registerTaskBoardPanel(ctx: ClientContext, controller: BoardController): () => void {
+  const slots = ctx.slots as {
+    inject(key: string, callback: () => () => void): () => void
+    register(options: Record<string, unknown>, component: unknown): () => void
+  }
+  const disposers: Array<() => void> = []
+
+  disposers.push(slots.inject('sidebar.panellist', () => slots.register({
+    name: 'sidebar.panellist',
+    id: TASK_BOARD_PANEL_ID,
+    order: PANEL_ORDER,
+    // The shell resolves this through resolveSlotLabel on every locale change,
+    // so the module-level translate reads the active language at call time.
+    label: () => t('entry.label'),
+  }, TaskBoardPanelIcon)))
+
+  disposers.push(slots.inject('main', () => slots.register({
+    name: 'main',
+    key: TASK_BOARD_PANEL_ID,
+    inject: (): PanelFace => ({ controller }),
+  }, TaskBoardPanel as never)))
+
+  return () => {
+    for (const dispose of disposers.splice(0)) dispose()
+  }
+}