@fonlan/dsh-task-kanban 0.2.6 → 0.2.7

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/settings.ts

@@ -1,27 +1,28 @@
 /**
  * User-facing plugin settings (global parallel worker count, per-session-type
- * model/effort/preset defaults), persisted through the settings service
- * namespace `task-kanban`. The DSH settings service requires a lowercase
- * kebab-case namespace (/^[a-z][a-z0-9-]*$/), so the scoped package name
- * cannot be used here.
+ * model/effort/preset defaults), carried by this bundle's entry config: dsh
+ * >= 0.1.7 owns plugin settings as entry config (the plugin's `Config`
+ * schema), so the face reads the config it was applied with and persists
+ * updates through `settings.update`.
  */
 import type { Context } from '@deepseek-ai/cordis'
 import z from '@deepseek-ai/schemastery'
 import type { KanbanSessionKind, KanbanSettingsShape } from '../shared/card.js'
-import type {} from '@deepseek-ai/dsh-settings'
 
 export const KANBAN_SETTINGS_NS = 'task-kanban'
 
-export const KanbanSettingsSchema = z.object({
-  maxParallelWorkers: z.natural().min(1).default(1),
-  refinementModel: z.string().default(''),
-  refinementProvider: z.string().default(''),
-  refinementReasoningEffort: z.string().default(''),
-  refinementPreset: z.string().default(''),
-  phaseModel: z.string().default(''),
-  phaseProvider: z.string().default(''),
-  phaseReasoningEffort: z.string().default(''),
-  phasePreset: z.string().default(''),
+export const KanbanSettingsSchema: z<KanbanSettingsShape> = z.object({
+  // Volatile: the settings plane (settings page / settings.update) only
+  // writes volatile-marked fields on dsh >= 0.1.7.
+  maxParallelWorkers: z.natural().min(1).default(1).volatile(),
+  refinementModel: z.string().default('').volatile(),
+  refinementProvider: z.string().default('').volatile(),
+  refinementReasoningEffort: z.string().default('').volatile(),
+  refinementPreset: z.string().default('').volatile(),
+  phaseModel: z.string().default('').volatile(),
+  phaseProvider: z.string().default('').volatile(),
+  phaseReasoningEffort: z.string().default('').volatile(),
+  phasePreset: z.string().default('').volatile(),
 })
 
 /** The per-session-type default slice a session kind resolves. */
@@ -47,38 +48,59 @@ export interface KanbanSettingsFace {
 
 /** Structural settings-service subset; the real service resolves the schema. */
 interface SettingsServiceLike {
-  register(ns: unknown, schema: unknown): unknown
   update(ns: unknown, patch: Record<string, unknown>, expectedRevision?: number): Promise<unknown>
 }
 
-const EMPTY_DEFAULTS: KanbanSessionDefaults = { model: '', provider: '', reasoningEffort: '', preset: '' }
+/** One config field as the loader hands it over: a stable volatile reference. */
+interface VolatileField<T> {
+  get(): T | undefined
+}
 
-export function registerSettings(ctx: Context): KanbanSettingsFace {
-  let current: KanbanSettingsShape = {
-    maxParallelWorkers: 1,
-    refinementModel: '',
-    refinementProvider: '',
-    refinementReasoningEffort: '',
-    refinementPreset: '',
-    phaseModel: '',
-    phaseProvider: '',
-    phaseReasoningEffort: '',
-    phasePreset: '',
+/**
+ * Dereference one config field. `Config` fields marked `.volatile()` are handed
+ * to the plugin as references (`{ get() }`) instead of plain values, so reading
+ * them raw yields the reference object — which serializes to `{}` and makes
+ * every setting look empty. Non-volatile (plain) configs keep working as-is.
+ */
+function fieldValue<T>(value: unknown, fallback: T): T {
+  if (value !== null && typeof value === 'object' && typeof (value as VolatileField<T>).get === 'function') {
+    return (value as VolatileField<T>).get() ?? fallback
   }
+  return (value as T | undefined) ?? fallback
+}
+
+const EMPTY_DEFAULTS: KanbanSessionDefaults = { model: '', provider: '', reasoningEffort: '', preset: '' }
+
+export function registerSettings(ctx: Context, config: KanbanSettingsShape): KanbanSettingsFace {
+  const fields = (config ?? {}) as unknown as Record<string, unknown>
+  // Read the references on EVERY access: the settings plane updates them in
+  // place (a volatile-only config change does not restart this entry).
+  const snapshot = (): KanbanSettingsShape => ({
+    maxParallelWorkers: fieldValue(fields.maxParallelWorkers, 1),
+    refinementModel: fieldValue(fields.refinementModel, ''),
+    refinementProvider: fieldValue(fields.refinementProvider, ''),
+    refinementReasoningEffort: fieldValue(fields.refinementReasoningEffort, ''),
+    refinementPreset: fieldValue(fields.refinementPreset, ''),
+    phaseModel: fieldValue(fields.phaseModel, ''),
+    phaseProvider: fieldValue(fields.phaseProvider, ''),
+    phaseReasoningEffort: fieldValue(fields.phaseReasoningEffort, ''),
+    phasePreset: fieldValue(fields.phasePreset, ''),
+  })
+  // Optimistic overlay: `settings.update` persists through the profile document
+  // and refreshes the references asynchronously, so the write's own caller must
+  // still observe the patch it just sent.
+  let pending: Partial<KanbanSettingsShape> = {}
+  const current = (): KanbanSettingsShape => ({ ...snapshot(), ...pending })
   let service: SettingsServiceLike | undefined
+  // Optional settings service: without one the settings still resolve from
+  // the entry config; edits just cannot persist.
   ctx.inject(['settings'], (sctx) => {
-    service = sctx.settings as unknown as SettingsServiceLike
-    const scope = service.register(KANBAN_SETTINGS_NS, KanbanSettingsSchema) as {
-      get(): KanbanSettingsShape
-      watch(callback: (next: KanbanSettingsShape) => void): () => void
-    }
-    current = scope.get()
-    scope.watch((next) => { current = next })
+    service = (sctx as unknown as { settings?: SettingsServiceLike }).settings
   })
   return {
-    get: () => current,
+    get: () => current(),
     sessionDefaults: (kind) => {
-      const s = current
+      const s = current()
       switch (kind) {
         case 'refine':
           return { model: s.refinementModel, provider: s.refinementProvider, reasoningEffort: s.refinementReasoningEffort, preset: s.refinementPreset }
@@ -108,7 +130,10 @@ export function registerSettings(ctx: Context): KanbanSettingsFace {
       if (service === undefined) {
         throw new Error('@fonlan/dsh-task-kanban: settings service is not available in this profile')
       }
+      // The settings plane keys plugin settings by PROFILE ENTRY id (the id in
+      // cordis.patch.yml), which is what this plugin ships.
       await service.update(KANBAN_SETTINGS_NS, patch as Record<string, unknown>)
+      pending = { ...pending, ...patch }
     },
   }
 }