@fonlan/dsh-task-kanban 0.2.6 → 0.2.8

package/src/client/index.tsx

@@ -6,9 +6,9 @@ import type {} from '@deepseek-ai/dsh-client-ui-layout/client'
 import type {} from '@deepseek-ai/dsh-client-ui-conversation/client'
 import type {} from '@deepseek-ai/dsh-client-ui-settings/client'
 import { BoardRoot } from './board'
-import { KanbanFooterButton, KanbanSettingsSection } from './sections'
+import { KanbanPanelIcon, KanbanSettingsSection } from './sections'
 import { LOCALE_NS, zh, en } from './locales'
-import { setClient, setBoardRoot, bindSessionNavigation } from './kanban-state'
+import { KANBAN_PANEL_ID, setClient } from './kanban-state'
 
 /** The settings sidebar entry this plugin's page owns (must stay stable). */
 const SETTINGS_SECTION_ID = 'task-kanban'
@@ -19,9 +19,9 @@ export const inject = ['slots', 'sessions', 'workspaces', 'locale']
 /** Client plugin body. */
 export function apply(ctx: ClientContext): void {
   setClient(ctx)
-  setBoardRoot(BoardRoot as unknown as (props: Record<string, unknown>) => React.ReactNode)
-  // Selecting a session while the board is open must leave the board first.
-  bindSessionNavigation(ctx)
+  // Session opening goes through the shell's own view owner
+  // (`ctx.uiWorkspace.openSession`, see kanban-state.ts), which already returns
+  // the center column to the Conversation — no wrapper to install here.
 
   // Live translate bound to the active locale (labels re-read it per call).
   const t = ctx.locale.bind(LOCALE_NS)
@@ -30,14 +30,30 @@ export function apply(ctx: ClientContext): void {
     return () => off()
   }, 'task-kanban: dictionaries')
 
-  ctx.slots.inject('sidebar.footer.action', () =>
+  // The board is a GLOBAL MAIN PANEL: the shell renders one `main` entry per
+  // selected panel id, so keying it (instead of replacing `main.conversation`)
+  // keeps the Conversation mounted and selectable beside the board, and the
+  // sidebar's own panel row owns the button that selects it (the
+  // `sidebar.panellist` entry below). Nothing of this plugin sits in the
+  // sidebar foot any more, so the Settings trigger can never be squeezed.
+  ctx.slots.inject('main', () =>
     ctx.slots.register({
-      name: 'sidebar.footer.action',
-      id: 'task-kanban',
-      order: 60,
+      name: 'main',
+      key: KANBAN_PANEL_ID,
+      locale: LOCALE_NS,
+    } as never, BoardRoot as never),
+  )
+
+  // Sidebar panel row: the shell renders the row (label, tooltip, active state)
+  // and calls `layout.selectPanel(id)` on click; the entry supplies the glyph.
+  ctx.slots.inject('sidebar.panellist', () =>
+    ctx.slots.register({
+      name: 'sidebar.panellist',
+      id: KANBAN_PANEL_ID,
+      order: 20,
       label: () => t('kanban'),
       locale: LOCALE_NS,
-    }, KanbanFooterButton as never),
+    }, KanbanPanelIcon as never),
   )
 
   // The plugin's own settings page (设置 -> 侧栏「任务看板」) rides the
@@ -53,4 +69,4 @@ export function apply(ctx: ClientContext): void {
       locale: LOCALE_NS,
     }, KanbanSettingsSection as never),
   )
-}
+}

package/src/client/kanban-state.ts

@@ -1,44 +1,51 @@
-import { useSyncExternalStore } from 'react'
 import type { Context } from '@deepseek-ai/cordis'
 type ClientContext = Context
 
 /**
- * HMR-safe shared state store keyed on the global symbol registry.
+ * Panel id shared by this plugin's main-panel key (`main`) and its sidebar
+ * entry (`sidebar.panellist`): the shell selects the panel by this id, so the
+ * two registrations must agree.
+ */
+export const KANBAN_PANEL_ID = 'task-kanban'
+
+/**
+ * Structural view of the client shell's panel-navigation face (`ctx.layout`).
+ * Declared locally (no value import) so the plugin keeps working on a runtime
+ * whose layout types differ.
+ */
+interface LayoutLike {
+  selectPanel(panelId: string | null): void
+}
+
+/**
+ * Structural view of the client shell's workspace-navigation face
+ * (`ctx.uiWorkspace`, dsh-client-ui-workspace). Declared locally (no value
+ * import) so the plugin keeps working on a runtime whose workspace types differ.
+ */
+interface UiWorkspaceLike {
+  /** Select a Session (id, or a direct-parent subagent address) and show it. */
+  openSession(target: string): void
+}
+
+/**
+ * HMR-safe owner context, keyed on the global symbol registry.
  *
  * The client-hmr hot swap re-evaluates this module (a fresh `lib/client.js`
- * bundle) WITHOUT reloading the page. A module-level singleton would then be
- * duplicated per evaluation: the session-navigation wrapper installed by the
- * OLD module copy keeps calling the OLD copy's `exitBoard`, which reads the
- * OLD copy's `boardOpen`/`boardDisposer` — while a board opened after the swap
- * writes the NEW copy's state cell. The wrapper would then no-op and clicking
- * a sidebar session would never leave the board.
- *
- * Keeping every field on one `globalThis`-backed record (via `Symbol.for`, so
- * all bundle copies resolve the same key) makes every copy read/write the same
- * state cell, so exit works regardless of which module copy performed the
- * enter.
+ * bundle) WITHOUT reloading the page; a module-level cell would then be
+ * duplicated per evaluation and an old copy's helper would read a stale owner.
+ * `Symbol.for` makes every bundle copy share one cell.
  */
 const STATE_KEY = Symbol.for('@fonlan/dsh-task-kanban/state')
 
 interface KanbanState {
   client: ClientContext | null
-  boardRoot: ((props: Record<string, unknown>) => React.ReactNode) | null
-  boardDisposer: (() => void) | null
-  boardOpen: boolean
-  listeners: Set<() => void>
 }
 
 function getState(): KanbanState {
   const g = globalThis as unknown as Record<symbol, KanbanState | undefined>
   let state = g[STATE_KEY]
   if (state === undefined) {
-    state = {
-      client: null,
-      boardRoot: null,
-      boardDisposer: null,
-      boardOpen: false,
-      listeners: new Set(),
-    }
+    state = { client: null }
     g[STATE_KEY] = state
   }
   return state
@@ -51,102 +58,67 @@ export function getClient(): ClientContext | null {
   return getState().client
 }
 
-export function setBoardRoot(component: (props: Record<string, unknown>) => React.ReactNode): void {
-  getState().boardRoot = component
-}
-export function getBoardRoot(): ((props: Record<string, unknown>) => React.ReactNode) | null {
-  return getState().boardRoot
-}
-
-function notify(): void {
-  for (const listener of getState().listeners) listener()
-}
-export function isBoardOpen(): boolean {
-  return getState().boardOpen
-}
-function subscribe(cb: () => void): () => void {
-  const listeners = getState().listeners
-  listeners.add(cb)
-  return () => { listeners.delete(cb) }
-}
-export function useBoardOpen(): boolean {
-  return useSyncExternalStore(subscribe, isBoardOpen)
+/** The shell's panel face, when this runtime provides it. */
+function layoutOf(ctx: ClientContext | null): LayoutLike | null {
+  if (ctx === null) return null
+  try {
+    const layout = (ctx as unknown as { layout?: LayoutLike }).layout
+    return typeof layout?.selectPanel === 'function' ? layout : null
+  } catch {
+    return null
+  }
 }
 
-export function enterBoard(): void {
-  const state = getState()
-  const ctx = state.client
-  const root = state.boardRoot
-  if (ctx === null || root === null || state.boardDisposer !== null) return
+/** Select the kanban panel. The sidebar's own entry does this; kept for in-app callers. */
+export function showKanbanPanel(ctx: ClientContext | null = getClient()): void {
   try {
-    // DSH 0.1.5 moved the replaceable shell from the legacy `conversation`
-    // seat to `main.conversation`. Register through `inject` so the board
-    // waits for that owner if the client plugin load order is reversed.
-    state.boardDisposer = ctx.slots.inject('main.conversation', () =>
-      ctx.slots.register({ name: 'main.conversation', priority: -1, locale: 'task-kanban' } as never, root as never),
-    )
-    state.boardOpen = true
-    notify()
+    layoutOf(ctx)?.selectPanel(KANBAN_PANEL_ID)
   } catch (error) {
-    console.error('[@fonlan/dsh-task-kanban] cannot open the board:', error)
+    console.error('[@fonlan/dsh-task-kanban] cannot select the kanban panel:', error)
   }
 }
 
-export function exitBoard(): void {
-  const state = getState()
-  if (state.boardDisposer !== null) {
-    state.boardDisposer()
-    state.boardDisposer = null
-  }
-  if (state.boardOpen) {
-    state.boardOpen = false
-    notify()
+/** Hand the center column back to the Conversation. */
+export function leaveKanbanPanel(ctx: ClientContext | null = getClient()): void {
+  try {
+    layoutOf(ctx)?.selectPanel(null)
+  } catch (error) {
+    console.error('[@fonlan/dsh-task-kanban] cannot leave the kanban panel:', error)
   }
 }
 
-export function toggleBoard(): void {
-  if (isBoardOpen()) exitBoard()
-  else enterBoard()
-}
-
 /**
- * Route session navigation through the board: opening any session while the
- * board is open leaves the board first, so the conversation view can render
- * for the newly selected session.
+ * Open one session — or a durable direct-parent subagent address — in the
+ * center column, leaving the kanban panel.
  *
- * Every sidebar path that selects a session funnels through `sessions.open`
- * (session rows, search results, fork results, New Session) or
- * `sessions.openSubagent` (catalog children) — including re-clicking the
- * already-current session, which never changes `list.current` and therefore
- * cannot be caught by a list-store subscription. Wrapping the two entry
- * points covers all of them in one place.
+ * Navigation is a view-owner concern, not a session-controller one: `ctx.sessions`
+ * (`ISessions`) exposes retention (`retain`/`using`/`retainInfo`), creation,
+ * fork, search and catalog reads, and has no `open`/`openSubagent` at all
+ * ("navigation belongs to view owners"). The view owner the shell itself uses is
+ * `ctx.uiWorkspace.openSession(target)` (dsh-client-ui-workspace): it retains the
+ * session AND reveals the Conversation panel as ONE navigation action. Routing
+ * every open through it therefore replaces the old wrapper around
+ * `sessions.open`/`openSubagent`, which existed only to hand the center column
+ * back when a sidebar click selected a session while the board was showing.
  *
- * The wrapper is idempotent: a `kbBound` marker on the wrapper prevents a
- * second bind (plugin re-apply / HMR) from stacking another layer. Because the
- * wrapper's exit goes through the shared state store, a wrapper left over from
- * a previous (HMR-replaced) module copy still closes the board correctly.
+ * @param target - session id (or subagent address) to show.
+ * @returns whether the runtime provided the navigation face; `false` means the
+ *   session could not be shown (a client without ui-workspace).
  */
-export function bindSessionNavigation(ctx: ClientContext): void {
-  const sessions = ctx.sessions
-  if (sessions === undefined) return
-
-  const open = sessions.open
-  if (typeof open === 'function' && (open as unknown as { kbBound?: boolean }).kbBound !== true) {
-    const bound = ((id: Parameters<typeof open>[0]) => {
-      exitBoard()
-      return open.call(sessions, id)
-    }) as typeof open
-    ;(bound as unknown as { kbBound?: boolean }).kbBound = true
-    sessions.open = bound
+export function openSessionView(target: string, ctx: ClientContext | null = getClient()): boolean {
+  if (ctx === null) return false
+  let uiWorkspace: UiWorkspaceLike | undefined
+  try {
+    uiWorkspace = (ctx as unknown as { uiWorkspace?: UiWorkspaceLike }).uiWorkspace
+  } catch {
+    return false
   }
-
-  const openSubagent = sessions.openSubagent
-  if (typeof openSubagent === 'function' && (openSubagent as unknown as { kbBound?: boolean }).kbBound !== true) {
-    const bound = ((address: Parameters<typeof openSubagent>[0]) => {
-      exitBoard()
-      return openSubagent.call(sessions, address)
-    }) as typeof openSubagent
-    ;(bound as unknown as { kbBound?: boolean }).kbBound = true
-    sessions.openSubagent = bound
+  if (typeof uiWorkspace?.openSession !== 'function') return false
+  try {
+    uiWorkspace.openSession(target)
+    return true
+  } catch (error) {
+    console.error('[@fonlan/dsh-task-kanban] cannot open the session view:', error)
+    return false
   }
-}
+}

package/src/client/sections.tsx

@@ -1,143 +1,17 @@
 import { useCallback, useEffect, useRef, useState } from 'react'
-import { IconChecklistOutline14 } from '@deepseek-ai/dsh-client-ui-primitives'
+import { ChecklistIcon } from './icons'
 import { api, type PresetOption, type ReasoningOptions } from './api'
-import { toggleBoard, useBoardOpen } from './kanban-state'
 import type { KanbanSettingsShape, ModelOption } from '../shared/card'
 
-interface FooterActionProps {
-  wide?: boolean
-  t?: (key: string) => string
-}
-
-/** Sidebar footer entry: toggles the kanban board main view.
- *  The shell renders footer actions on their own row ABOVE the settings row,
- *  so the button is reparented into the settings area to sit on the same
- *  line, right of the Settings trigger (see board.css .kb-settings-row). */
-export function KanbanFooterButton({ wide, t }: FooterActionProps): JSX.Element {
-  const open = useBoardOpen()
-  const ref = useRef<HTMLButtonElement | null>(null)
-  const label = t !== undefined ? t(open ? 'closeBoard' : 'openBoard') : 'Task Kanban'
-
-  useEffect(() => {
-    const btn = ref.current
-    if (btn === null) return
-    let foot: Element | null = null
-    let disposed = false
-
-    // Locate the sidebar foot area WITHOUT moving any DOM: it is the ancestor
-    // of the button whose LAST child contains the settings trigger and which
-    // is itself the last child of its parent (root > footArea > settingsArea).
-    // The slot machinery wraps entries in an anonymous div, so the search
-    // tolerates extra wrapper levels. Styling is pure CSS (see board.css
-    // .kb-foot-row), so a failed lookup only leaves the button in its natural
-    // slot row — it can never vanish.
-    const findFoot = (): Element | null => {
-      let el: Element | null = btn.parentElement
-      while (el !== null && el !== document.body && el.parentElement !== null) {
-        const last = el.lastElementChild
-        const hasTrigger =
-          last !== null &&
-          (last.querySelector?.('button[aria-haspopup="dialog"]') !== null ||
-            last.querySelector?.('button[aria-haspopup="menu"]') !== null)
-        const isLastChild = el.parentElement.lastElementChild === el
-        if (hasTrigger && isLastChild) return el
-        el = el.parentElement
-      }
-      return null
-    }
-
-    const tryApply = (): boolean => {
-      if (foot === null) {
-        try {
-          foot = findFoot()
-        } catch {
-          foot = null
-        }
-      }
-      if (foot === null) return false
-      try {
-        foot.classList.add('kb-foot-row')
-        foot.classList.toggle('kb-foot-rail', wide !== true)
-      } catch {
-        // element already gone; retry will re-locate
-      }
-      return true
-    }
-
-    let applied = false
-    try {
-      applied = tryApply()
-    } catch (error) {
-      console.error('[@fonlan/dsh-task-kanban] foot placement error:', error)
-    }
-    if (!applied) {
-      // The settings entry may mount later than this entry (plugin load
-      // order); retry on DOM mutations AND on a short interval until the
-      // foot area is found (give up after 15s).
-      const observer = new MutationObserver(() => {
-        if (disposed) return
-        if (tryApply()) observer.disconnect()
-      })
-      observer.observe(document.body, { childList: true, subtree: true })
-      const timer = window.setInterval(() => {
-        if (disposed) {
-          window.clearInterval(timer)
-          return
-        }
-        if (tryApply()) {
-          observer.disconnect()
-          window.clearInterval(timer)
-        }
-      }, 1000)
-      window.setTimeout(() => {
-        observer.disconnect()
-        window.clearInterval(timer)
-        if (foot === null) {
-          // report the DOM chain so the next report carries evidence
-          const chain: string[] = []
-          let el: Element | null = btn.parentElement
-          while (el !== null && chain.length < 8) {
-            chain.push(el.tagName + '.' + String(el.className).slice(0, 60))
-            el = el.parentElement
-          }
-          console.warn('[@fonlan/dsh-task-kanban] could not locate the sidebar foot area:', chain)
-        }
-      }, 15000)
-      return () => {
-        disposed = true
-        observer.disconnect()
-        window.clearInterval(timer)
-        try {
-          foot?.classList.remove('kb-foot-row')
-          foot?.classList.remove('kb-foot-rail')
-        } catch {
-          // already gone
-        }
-      }
-    }
-    return () => {
-      try {
-        foot?.classList.remove('kb-foot-row')
-        foot?.classList.remove('kb-foot-rail')
-      } catch {
-        // already gone
-      }
-    }
-  }, [wide])
-
-  return (
-    <button
-      ref={ref}
-      type="button"
-      className={'kb-footer-action' + (wide === true ? ' kb-footer-action-wide' : '') + (open ? ' kb-footer-action-active' : '')}
-      aria-label={label}
-      title={label}
-      onClick={() => toggleBoard()}
-    >
-      <IconChecklistOutline14 size={wide === true ? 16 : 18} />
-      {wide === true && <span className="kb-footer-label">{t !== undefined ? t('kanban') : 'Kanban'}</span>}
-    </button>
-  )
+/**
+ * Sidebar panel-row glyph for the board (`sidebar.panellist`).
+ *
+ * The shell owns the row: it renders the button, its label, tooltip and active
+ * state, and calls `layout.selectPanel(id)` on click. The entry contributes
+ * only the glyph, so this component must stay purely presentational.
+ */
+export function KanbanPanelIcon({ size }: { size: number }): JSX.Element {
+  return <ChecklistIcon size={size} />
 }
 
 interface SettingsSectionProps {

package/src/index.ts

@@ -7,20 +7,22 @@
  * serves the fenced JSON API the board UI calls.
  */
 import type { Context } from '@deepseek-ai/cordis'
-import z from '@deepseek-ai/schemastery'
-import { registerSettings } from './server/settings.js'
+import { KanbanSettingsSchema, registerSettings } from './server/settings.js'
 import { TaskStore } from './server/task-store.js'
 import { KanbanRunner } from './server/runner.js'
 import { registerApiRoutes } from './server/rpc.js'
+import type { KanbanSettingsShape } from './shared/card.js'
 
 export const name = '@fonlan/dsh-task-kanban'
 
 export const inject = ['webServer', 'agents', 'skills']
 
-export const Config = z.object({})
+// The entry config is the settings document (worker count + per-session-type
+// defaults); a changed config restarts this entry.
+export const Config = KanbanSettingsSchema
 
-export function apply(ctx: Context, _config: unknown): void {
-  const settings = registerSettings(ctx)
+export function apply(ctx: Context, config: KanbanSettingsShape): void {
+  const settings = registerSettings(ctx, config)
   const store = new TaskStore()
   const runner = new KanbanRunner(ctx, store, settings)
 

package/src/server/runner.ts

@@ -19,7 +19,14 @@ import { currentBranch, detectBaseRef, hasStashMessage, isGitRepo, isTreeDirty,
 import { interactiveRefinementPrompt, mergePrompt, phasePrompt, refinementPrompt } from './prompts.js'
 import { loadCardSkill, parseSkillGesture, skillInvocationMessage } from './skills.js'
 import { registerKanbanTools, type KanbanToolResolver } from './tools.js'
-import type {} from '@deepseek-ai/dsh-agent-presets'
+// Declaration-merge only (erased at runtime): loads the `agentPresets` service
+// augmentation for `ctx.get('agentPresets')` below. The 0.1.x name
+// `@deepseek-ai/dsh-agent-presets` stopped shipping after 0.1.5-rc.3 and does
+// not exist at 0.2.0-rc.1; `@deepseek-ai/dsh-agent-preset` ships on both live
+// runtimes and carries the same `agentPresets` Context augmentation (it depends
+// on `@deepseek-ai/dsh-agent-preset-registry`, which owns the service and the
+// augmentation).
+import type {} from '@deepseek-ai/dsh-agent-preset'
 
 const WORKTREES_REL = ['.dsh', 'worktrees']
 
@@ -59,7 +66,7 @@ export class KanbanRunner implements KanbanToolResolver {
   private recovered = false
   /** Agents that already got their scoped kanban tools (event idempotency). */
   private toolScopedAgents = new WeakSet<object>()
-  private agentStartOff: (() => void) | undefined
+  private agentCreatedOff: (() => void) | undefined
 
   constructor(ctx: Context, store: TaskStore, settings: KanbanSettingsFace) {
     this.ctx = ctx
@@ -73,21 +80,28 @@ export class KanbanRunner implements KanbanToolResolver {
 
   start(): void {
     this.pumpTimer = setInterval(() => { void this.pump() }, 2500)
-    // `agent/session-start` fires for BOTH agents.create (startup) and
-    // agents.resume (host re-open after a restart). Kanban tools are scoped
-    // per agent, so a resumed refinement/phase/merge session would otherwise
-    // lose them — register there instead of only in createAgent's setup.
-    this.agentStartOff = this.ctx.on('agent/session-start', (payload: { agent?: { id?: string; ctx?: Context } }) => {
-      void this.onAgentSessionStart(payload.agent)
+    // `agent/created` is the lifecycle edge for an agent that entered the
+    // registry — dsh announces every creation path through it, including
+    // `agents.resume` (the factory re-opens a persisted session's agent after a
+    // host restart), and its `source` records which path that was. The previous
+    // subscription used `agent/session-start`, which existed in dsh 0.1.5 only
+    // and was already gone by 0.1.7 — so resumed refinement/phase/merge
+    // sessions silently lost their scoped kanban tools. `agent/created` exists
+    // in 0.1.7-rc.2 and 0.2.0-rc.1 with the same `{ agent, source }` payload.
+    // It dispatches as a serial listener, so this callback must not reject:
+    // tool registration is best-effort and a lookup failure must not fail the
+    // host's agent creation (hence the floating promise).
+    this.agentCreatedOff = this.ctx.on('agent/created', (payload: { agent?: { id?: string; ctx?: Context } }): undefined => {
+      void this.onAgentCreated(payload.agent)
     })
   }
 
   stop(): void {
     if (this.pumpTimer !== undefined) clearInterval(this.pumpTimer)
     this.pumpTimer = undefined
-    if (this.agentStartOff !== undefined) {
-      this.agentStartOff()
-      this.agentStartOff = undefined
+    if (this.agentCreatedOff !== undefined) {
+      this.agentCreatedOff()
+      this.agentCreatedOff = undefined
     }
   }
 
@@ -217,12 +231,13 @@ export class KanbanRunner implements KanbanToolResolver {
   }
 
   /**
-   * The single place kanban tools get registered. `agent/session-start` fires
-   * for BOTH `agents.create` (startup) and `agents.resume` (host re-open after
-   * a restart), so a resumed refinement/phase/merge session keeps its scoped
+   * The single place kanban tools get registered. Subscribed to
+   * `agent/created`, which fires for BOTH `agents.create` (startup) and
+   * `agents.resume` (host re-open after a restart) and carries the path in its
+   * `source`, so a resumed refinement/phase/merge session keeps its scoped
    * tools. Idempotent per agent object; non-kanban sessions are skipped.
    */
-  private async onAgentSessionStart(agent: { id?: string; ctx?: Context } | undefined): Promise<void> {
+  private async onAgentCreated(agent: { id?: string; ctx?: Context } | undefined): Promise<void> {
     if (agent === undefined || agent.id === undefined || agent.ctx === undefined) return
     if (this.toolScopedAgents.has(agent)) return
     let cardId = this.sessionCards.get(agent.id)
@@ -611,9 +626,9 @@ export class KanbanRunner implements KanbanToolResolver {
       sessionId,
       meta: { cwd, ...(presetId !== undefined ? { agentPreset: presetId } : {}) },
       ...(agentOptions !== undefined ? { agentOptions } : {}),
-      // Kanban tools are NOT registered here: `agent/session-start` (see
-      // start()) fires for both create and resume, keeping them available
-      // even when the host re-opens a persisted kanban session.
+      // Kanban tools are NOT registered here: `agent/created` (see start())
+      // fires for both create and resume, keeping them available even when the
+      // host re-opens a persisted kanban session.
       setup: async (agentCtx) => {
         const agentPresets = agentCtx.get('agentPresets') as
           | { mount(agentCtx: unknown, id?: string): Promise<unknown> }