@fonlan/dsh-task-kanban 0.1.1 → 0.2.1

package/src/server/runner.ts

@@ -10,9 +10,9 @@ import { appendFile, readFile } from 'node:fs/promises'
 import type { Session, SessionEvent, SessionId } from '@deepseek-ai/dsh-session'
 import { join } from 'node:path'
 import type { Context } from '@deepseek-ai/cordis'
-import { createUserMessage } from '@deepseek-ai/dsh-llm'
-import type { AgentHandle } from '@deepseek-ai/dsh-agent'
-import type { KanbanCard, ErrorKind, Lane, Plan } from '../shared/card.js'
+import { createUserMessage, ReasoningEffortId } from '@deepseek-ai/dsh-llm'
+import { installModelSelection, type AgentHandle, type ModelSelectionRef } from '@deepseek-ai/dsh-agent'
+import type { KanbanCard, ErrorKind, KanbanSessionKind, Lane, Plan } from '../shared/card.js'
 import type { TaskStore } from './task-store.js'
 import type { KanbanSettingsFace } from './settings.js'
 import { currentBranch, detectBaseRef, hasStashMessage, isGitRepo, isTreeDirty, revParse, runGit, unmergedPaths } from './git.js'
@@ -49,6 +49,11 @@ export class KanbanRunner implements KanbanToolResolver {
   private merging = new Set<string>()
   /** Retained agent handles (kept so ended sessions stay in the store/UI). */
   private handles = new Map<string, AgentHandle[]>()
+  /** Whether startup recovery + session indexing ran (deferred until workspaces exist). */
+  private recovered = false
+  /** Agents that already got their scoped kanban tools (event idempotency). */
+  private toolScopedAgents = new WeakSet<object>()
+  private agentStartOff: (() => void) | undefined
 
   constructor(ctx: Context, store: TaskStore, settings: KanbanSettingsFace) {
     this.ctx = ctx
@@ -62,10 +67,22 @@ 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)
+    })
   }
 
   stop(): void {
     if (this.pumpTimer !== undefined) clearInterval(this.pumpTimer)
+    this.pumpTimer = undefined
+    if (this.agentStartOff !== undefined) {
+      this.agentStartOff()
+      this.agentStartOff = undefined
+    }
   }
 
   private newSessionId(): SessionId {
@@ -157,6 +174,63 @@ export class KanbanRunner implements KanbanToolResolver {
     }
   }
 
+  /**
+   * Rebuild sessionId → cardId from the task store. Runs once the workspace
+   * registry is available (see pump), so kanban sessions resumed after a
+   * restart still resolve their card.
+   */
+  private async indexSessions(): Promise<void> {
+    for (const ws of await this.workspaceList()) {
+      const cards = await this.store.list(ws.path)
+      for (const card of cards) this.mapCardSessions(card.id, card)
+    }
+  }
+
+  private mapCardSessions(cardId: string, card: KanbanCard): void {
+    for (const sid of card.sessions.refinement) this.sessionCards.set(sid, cardId)
+    for (const attempt of card.sessions.phases) this.sessionCards.set(attempt.sessionId, cardId)
+    for (const sid of card.sessions.merge) this.sessionCards.set(sid, cardId)
+  }
+
+  /** Fallback lookup when a session starts before indexSessions ran. */
+  private async lookupCardOfSession(sessionId: string): Promise<string | undefined> {
+    for (const ws of await this.workspaceList()) {
+      const cards = await this.store.list(ws.path)
+      for (const card of cards) {
+        const hit =
+          card.sessions.refinement.includes(sessionId) ||
+          card.sessions.phases.some((a) => a.sessionId === sessionId) ||
+          card.sessions.merge.includes(sessionId)
+        if (hit) {
+          this.mapCardSessions(card.id, card)
+          return card.id
+        }
+      }
+    }
+    return undefined
+  }
+
+  /**
+   * 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
+   * tools. Idempotent per agent object; non-kanban sessions are skipped.
+   */
+  private async onAgentSessionStart(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)
+    if (cardId === undefined) cardId = await this.lookupCardOfSession(agent.id)
+    if (cardId === undefined) return
+    this.sessionCards.set(agent.id, cardId)
+    try {
+      registerKanbanTools(agent.ctx, this.toolResolver())
+      this.toolScopedAgents.add(agent)
+    } catch (error) {
+      console.error('[task-kanban] register kanban tools for ' + agent.id + ' failed:', String(error))
+    }
+  }
+
   // ── Card operations (RPC entry points) ────────────────────────────────────
 
   async listCards(workspacePath: string): Promise<KanbanCard[]> {
@@ -287,6 +361,26 @@ export class KanbanRunner implements KanbanToolResolver {
   }
 
   async pump(): Promise<void> {
+    // Recovery and session indexing need the workspace registry, which may
+    // not be populated when the plugin first applies (the old code silently
+    // no-opped and left interrupted cards stuck in refining). Retry on the
+    // pump tick until the first workspace appears.
+    if (!this.recovered) {
+      const ws = await this.workspaceList()
+      if (ws.length > 0) {
+        this.recovered = true
+        try {
+          await this.recoverInterrupted()
+        } catch (error) {
+          console.error('[task-kanban] recoverInterrupted failed:', String(error))
+        }
+        try {
+          await this.indexSessions()
+        } catch (error) {
+          console.error('[task-kanban] indexSessions failed:', String(error))
+        }
+      }
+    }
     if (this.slots >= this.maxParallel()) return
     const workspaces = await this.workspaceList()
     for (const ws of workspaces) {
@@ -331,7 +425,7 @@ export class KanbanRunner implements KanbanToolResolver {
   private async runRefinement(cardId: string, wsPath: string): Promise<void> {
     const card = await this.store.get(wsPath, cardId)
     if (card === undefined) return
-    const route = await this.modelRoute(cardId, wsPath)
+    const route = await this.modelRoute(cardId, wsPath, 'refine')
     const sessionId = this.newSessionId()
     this.sessionCards.set(sessionId, cardId)
     await this.store.mutate(cardId, (c) => {
@@ -340,7 +434,7 @@ export class KanbanRunner implements KanbanToolResolver {
       c.sessions.refinement.push(sessionId)
     }, wsPath)
     try {
-      const handle = await this.createAgent(sessionId, wsPath, route, this.toolResolver())
+      const handle = await this.createAgent(sessionId, wsPath, route, 'refine')
       this.keepHandle(cardId, handle)
       await this.attachRefinementSession(wsPath, sessionId)
       // The agent scope is the layer where preset skill providers live
@@ -462,30 +556,70 @@ export class KanbanRunner implements KanbanToolResolver {
     return { promise, dispose }
   }
 
+  /**
+   * Create one kanban session agent. `kind` decides the per-session preset:
+   * refine/phase use their settings default (falling back to the roster's
+   * default preset when unset), merge keeps the historical 'standard' preset.
+   * When the kind defaults configure a reasoning effort, an
+   * `installModelSelection` ref couples the provider/model + effort into every
+   * prompt assembly and model request. Without a configured effort no
+   * selection is installed: `agentOptions` carries the route and the loop
+   * materializes the model's own default effort — the historical behavior.
+   */
   private async createAgent(
     sessionId: SessionId,
     cwd: string,
-    route: { provider?: string; model?: string },
-    resolver: KanbanToolResolver,
+    route: { provider?: string; model?: string; reasoningEffort?: string },
+    kind: KanbanSessionKind,
   ) {
     const agentOptions =
       route.provider !== undefined && route.model !== undefined && route.model !== ''
         ? { provider: route.provider, model: route.model }
         : undefined
+    const selectionRef: ModelSelectionRef = {
+      current:
+        route.provider !== undefined && route.model !== undefined && route.model !== ''
+          ? {
+              provider: route.provider,
+              model: route.model,
+              ...(route.reasoningEffort !== undefined && route.reasoningEffort !== ''
+                ? { reasoningEffort: ReasoningEffortId(route.reasoningEffort) }
+                : {}),
+            }
+          : undefined,
+      assembled: undefined,
+    }
+    // Resolve the preset id BEFORE creation so the session header records the
+    // exact composition it runs under (a resumed kanban session then rebuilds
+    // the same preset instead of the deployment default).
+    let presetId: string | undefined
+    const presets = this.ctx.get('agentPresets') as
+      | { resolve(id?: string): Promise<{ id: string }> }
+      | undefined
+    if (presets !== undefined) {
+      const requested = kind === 'merge' ? 'standard' : this.settings.sessionDefaults(kind).preset
+      const resolved = await presets.resolve(requested === '' ? undefined : requested)
+      presetId = resolved.id
+    }
     return this.ctx.agents.create({
       sessionId,
-      meta: { cwd },
+      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.
       setup: async (agentCtx) => {
         const agentPresets = agentCtx.get('agentPresets') as
           | { mount(agentCtx: unknown, id?: string): Promise<unknown> }
           | undefined
         if (agentPresets !== undefined) {
-          await agentPresets.mount(agentCtx, 'standard')
+          await agentPresets.mount(agentCtx, presetId)
         } else {
           throw new Error('@fonlan/dsh-task-kanban: agent-presets service is not mounted')
         }
-        registerKanbanTools(agentCtx, resolver)
+        if (selectionRef.current !== undefined && selectionRef.current.reasoningEffort !== undefined) {
+          installModelSelection(agentCtx, selectionRef)
+        }
       },
     })
   }
@@ -524,8 +658,19 @@ export class KanbanRunner implements KanbanToolResolver {
     return undefined
   }
 
-  /** Resolve the provider+model route for an agent (both are required). */
-  private async modelRoute(cardId: string, wsPath: string): Promise<{ provider?: string; model?: string }> {
+  /**
+   * Resolve the provider+model route for an agent (both are required), plus
+   * the per-kind reasoning effort. Precedence per kind:
+   *   1. the card's explicit model (chosen at creation) — wins for every kind;
+   *   2. the session-kind defaults (refine/phase settings);
+   *   3. the host `agent-default-model` route.
+   * Merge sessions skip step 2 (no per-type defaults for them).
+   */
+  private async modelRoute(
+    cardId: string,
+    wsPath: string,
+    kind: KanbanSessionKind,
+  ): Promise<{ provider?: string; model?: string; reasoningEffort?: string }> {
     const card = await this.store.get(wsPath, cardId)
     if (card === undefined) return {}
     if (card.model !== '' && card.provider !== undefined && card.provider !== '') {
@@ -535,10 +680,13 @@ export class KanbanRunner implements KanbanToolResolver {
       const fallback = this.settings.defaultModelRoute()
       return fallback.provider !== undefined ? { provider: fallback.provider, model: card.model } : { model: card.model }
     }
-    const userDefault = this.settings.get().defaultModel
-    if (userDefault !== '') {
-      const fallback = this.settings.defaultModelRoute()
-      return fallback.provider !== undefined ? { provider: fallback.provider, model: userDefault } : { model: userDefault }
+    const kindDefaults = this.settings.sessionDefaults(kind)
+    if (kindDefaults.model !== '') {
+      return {
+        ...(kindDefaults.provider !== '' ? { provider: kindDefaults.provider } : {}),
+        model: kindDefaults.model,
+        ...(kindDefaults.reasoningEffort !== '' ? { reasoningEffort: kindDefaults.reasoningEffort } : {}),
+      }
     }
     return this.settings.defaultModelRoute()
   }
@@ -636,9 +784,9 @@ export class KanbanRunner implements KanbanToolResolver {
       c.error = undefined
       c.sessions.phases.push({ phaseIndex, sessionId, startedAt: Date.now() })
     }, wsPath)
-    const route = await this.modelRoute(cardId, wsPath)
+    const route = await this.modelRoute(cardId, wsPath, 'phase')
     try {
-      const handle = await this.createAgent(sessionId, workdir, route, this.toolResolver())
+      const handle = await this.createAgent(sessionId, workdir, route, 'phase')
       this.keepHandle(cardId, handle)
       entry.cancel = () => handle.agent.cancel({ kind: 'user' })
       handle.agent.followup(this.asUserMessage(phasePrompt({ ...(await this.store.get(wsPath, cardId)) ?? { plan } as KanbanCard, plan } as KanbanCard, phaseIndex, workdir)))
@@ -889,9 +1037,9 @@ export class KanbanRunner implements KanbanToolResolver {
     const sessionId = this.newSessionId()
     this.sessionCards.set(sessionId, cardId)
     await this.store.mutate(cardId, (c) => { c.sessions.merge.push(sessionId) }, wsPath)
-    const route = await this.modelRoute(cardId, wsPath)
+    const route = await this.modelRoute(cardId, wsPath, 'merge')
     try {
-      const handle = await this.createAgent(sessionId, workdir, route, this.toolResolver())
+      const handle = await this.createAgent(sessionId, workdir, route, 'merge')
       this.keepHandle(cardId, handle)
       handle.agent.followup(this.asUserMessage(mergePrompt(workdir, conflicts)))
       await handle.agent.whenIdle()

package/src/server/settings.ts

@@ -1,26 +1,48 @@
 /**
- * User-facing plugin settings (global parallel worker count, default model),
- * 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.
+ * 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.
  */
 import type { Context } from '@deepseek-ai/cordis'
 import z from '@deepseek-ai/schemastery'
 import { settingsNamespace } from '@deepseek-ai/dsh-settings'
-import type { KanbanSettingsShape } from '../shared/card.js'
+import type { KanbanSessionKind, KanbanSettingsShape } from '../shared/card.js'
 
 export const KANBAN_SETTINGS_NS = settingsNamespace('task-kanban')
 
 export const KanbanSettingsSchema = z.object({
   maxParallelWorkers: z.natural().min(1).default(1),
-  defaultModel: z.string().default(''),
+  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(''),
 })
 
+/** The per-session-type default slice a session kind resolves. */
+export interface KanbanSessionDefaults {
+  model: string
+  provider: string
+  reasoningEffort: string
+  preset: string
+}
+
 export interface KanbanSettingsFace {
   get(): KanbanSettingsShape
   update(patch: Partial<KanbanSettingsShape>): Promise<void>
   /** Default provider/model route from the agent-default-model settings namespace. */
   defaultModelRoute(): { provider?: string; model?: string }
+  /**
+   * The configured model/effort/preset defaults for one session kind.
+   * `merge` sessions deliberately carry no per-type defaults: they keep the
+   * legacy resolution chain (card model → host default).
+   */
+  sessionDefaults(kind: KanbanSessionKind): KanbanSessionDefaults
 }
 
 /** Structural settings-service subset; the real service resolves the schema. */
@@ -29,8 +51,20 @@ interface SettingsServiceLike {
   update(ns: unknown, patch: Record<string, unknown>, expectedRevision?: number): Promise<unknown>
 }
 
+const EMPTY_DEFAULTS: KanbanSessionDefaults = { model: '', provider: '', reasoningEffort: '', preset: '' }
+
 export function registerSettings(ctx: Context): KanbanSettingsFace {
-  let current: KanbanSettingsShape = { maxParallelWorkers: 1, defaultModel: '' }
+  let current: KanbanSettingsShape = {
+    maxParallelWorkers: 1,
+    refinementModel: '',
+    refinementProvider: '',
+    refinementReasoningEffort: '',
+    refinementPreset: '',
+    phaseModel: '',
+    phaseProvider: '',
+    phaseReasoningEffort: '',
+    phasePreset: '',
+  }
   let service: SettingsServiceLike | undefined
   ctx.inject(['settings'], (sctx) => {
     service = sctx.settings as unknown as SettingsServiceLike
@@ -43,6 +77,17 @@ export function registerSettings(ctx: Context): KanbanSettingsFace {
   })
   return {
     get: () => current,
+    sessionDefaults: (kind) => {
+      const s = current
+      switch (kind) {
+        case 'refine':
+          return { model: s.refinementModel, provider: s.refinementProvider, reasoningEffort: s.refinementReasoningEffort, preset: s.refinementPreset }
+        case 'phase':
+          return { model: s.phaseModel, provider: s.phaseProvider, reasoningEffort: s.phaseReasoningEffort, preset: s.phasePreset }
+        case 'merge':
+          return EMPTY_DEFAULTS
+      }
+    },
     defaultModelRoute: () => {
       if (service === undefined) return {}
       try {

package/src/shared/card.ts

@@ -111,7 +111,19 @@ export interface ModelOption {
   name?: string
 }
 
+/** Which kanban session kind a per-type default applies to. */
+export type KanbanSessionKind = 'refine' | 'phase' | 'merge'
+
 export interface KanbanSettingsShape {
   maxParallelWorkers: number
-  defaultModel: string
+  /** Requirement-refinement session defaults. */
+  refinementModel: string
+  refinementProvider: string
+  refinementReasoningEffort: string
+  refinementPreset: string
+  /** Phase implementation session defaults. */
+  phaseModel: string
+  phaseProvider: string
+  phaseReasoningEffort: string
+  phasePreset: string
 }