@fonlan/dsh-task-kanban 0.2.0 → 0.2.2

package/src/client/sections.tsx

@@ -1,8 +1,8 @@
-import { useEffect, useRef, useState } from 'react'
+import { useCallback, useEffect, useRef, useState } from 'react'
 import { IconChecklistOutline14 } from '@deepseek-ai/dsh-client-ui-primitives'
-import { api } from './api'
+import { api, type PresetOption, type ReasoningOptions } from './api'
 import { toggleBoard, useBoardOpen } from './kanban-state'
-import type { KanbanSettingsShape } from '../shared/card'
+import type { KanbanSettingsShape, ModelOption } from '../shared/card'
 
 interface FooterActionProps {
   wide?: boolean
@@ -140,17 +140,141 @@ export function KanbanFooterButton({ wide, t }: FooterActionProps): JSX.Element
   )
 }
 
-interface SettingsSectionProps {
+interface SettingsCardProps {
   t?: (key: string) => string
 }
 
-/** Plugin settings section: global parallel workers + default model. */
-export function KanbanSettingsSection({ t }: SettingsSectionProps): JSX.Element {
+/** Fallback shape while settings load (server always resolves the full set). */
+const EMPTY_SETTINGS: KanbanSettingsShape = {
+  maxParallelWorkers: 1,
+  refinementModel: '',
+  refinementProvider: '',
+  refinementReasoningEffort: '',
+  refinementPreset: '',
+  phaseModel: '',
+  phaseProvider: '',
+  phaseReasoningEffort: '',
+  phasePreset: '',
+}
+
+/** The setting field names of one session-type group. */
+const GROUP_FIELDS = {
+  refinement: {
+    model: 'refinementModel',
+    provider: 'refinementProvider',
+    effort: 'refinementReasoningEffort',
+    preset: 'refinementPreset',
+  },
+  phase: {
+    model: 'phaseModel',
+    provider: 'phaseProvider',
+    effort: 'phaseReasoningEffort',
+    preset: 'phasePreset',
+  },
+} as const
+
+type SessionGroupKey = keyof typeof GROUP_FIELDS
+
+interface SessionDefaultsGroupProps {
+  kind: SessionGroupKey
+  settings: KanbanSettingsShape
+  models: ModelOption[]
+  presets: PresetOption[]
+  /** Reasoning efforts already fetched, keyed `provider/model`. */
+  efforts: Record<string, ReasoningOptions>
+  tr: (key: string) => string
+  onCommit: (patch: Partial<KanbanSettingsShape>) => Promise<void>
+  loadEfforts: (provider: string, model: string) => void
+}
+
+/** Model / reasoning effort / agent preset defaults for one session type. */
+function SessionDefaultsGroup({ kind, settings, models, presets, efforts, tr, onCommit, loadEfforts }: SessionDefaultsGroupProps): JSX.Element {
+  const fields = GROUP_FIELDS[kind]
+  const model = settings[fields.model]
+  const provider = settings[fields.provider]
+  const effort = settings[fields.effort]
+  const preset = settings[fields.preset]
+  const effortKey = model !== '' && provider !== '' ? `${provider}/${model}` : ''
+  const effortOptions = effortKey !== '' ? (efforts[effortKey]?.efforts ?? []) : []
+
+  const handleModel = (id: string): void => {
+    const found = models.find((m) => m.id === id)
+    const nextProvider = found?.provider ?? ''
+    void onCommit({ [fields.model]: id, [fields.provider]: nextProvider } as Partial<KanbanSettingsShape>)
+    if (id !== '' && nextProvider !== '') loadEfforts(nextProvider, id)
+  }
+
+  return (
+    <div className="kb-settings-group">
+      <div className="kb-settings-group-title">{tr(kind === 'refinement' ? 'settingsRefineGroup' : 'settingsPhaseGroup')}</div>
+      <label className="kb-field kb-field-row">
+        <span>{tr('model')}</span>
+        <select className="kb-input" value={model} onChange={(e) => handleModel(e.target.value)}>
+          <option value="">{tr('defaultOption')}</option>
+          {models.map((m) => (
+            <option key={m.provider + '/' + m.id} value={m.id}>{m.name ?? m.id}</option>
+          ))}
+        </select>
+      </label>
+      <label className="kb-field kb-field-row">
+        <span>{tr('reasoningEffort')}</span>
+        <select
+          className="kb-input"
+          value={effort}
+          disabled={model === ''}
+          onChange={(e) => void onCommit({ [fields.effort]: e.target.value } as Partial<KanbanSettingsShape>)}
+        >
+          <option value="">{tr('defaultOption')}</option>
+          {effortOptions.map((o) => (
+            <option key={o.id} value={o.id}>{o.name}</option>
+          ))}
+        </select>
+      </label>
+      <label className="kb-field kb-field-row">
+        <span>{tr('agentPreset')}</span>
+        <select
+          className="kb-input"
+          value={preset}
+          onChange={(e) => void onCommit({ [fields.preset]: e.target.value } as Partial<KanbanSettingsShape>)}
+        >
+          <option value="">{tr('defaultOption')}</option>
+          {presets.map((p) => (
+            <option key={p.id} value={p.id}>{p.name ?? p.id}</option>
+          ))}
+        </select>
+      </label>
+    </div>
+  )
+}
+
+/** Plugin settings card (设置 → 插件配置): workers + default model + per-session-type defaults. */
+export function KanbanSettingsCard({ t }: SettingsCardProps): JSX.Element {
   const tr = t ?? ((key: string) => key)
-  const [settings, setSettings] = useState<KanbanSettingsShape>({ maxParallelWorkers: 1, defaultModel: '' })
-  const [models, setModels] = useState<Array<{ provider: string; id: string; name?: string }>>([])
+  // Card-local disclosure: collapsed by default, like the built-in plugin cards.
+  const [open, setOpen] = useState(false)
+  const [settings, setSettings] = useState<KanbanSettingsShape>(EMPTY_SETTINGS)
+  const [models, setModels] = useState<ModelOption[]>([])
+  const [presets, setPresets] = useState<PresetOption[]>([])
+  const [efforts, setEfforts] = useState<Record<string, ReasoningOptions>>({})
   const [saved, setSaved] = useState(false)
 
+  const commit = useCallback(async (patch: Partial<KanbanSettingsShape>): Promise<void> => {
+    try {
+      const next = await api.settingsSet(patch)
+      setSettings(next)
+      setSaved(true)
+      window.setTimeout(() => setSaved(false), 1500)
+    } catch {
+      // keep the previous value
+    }
+  }, [])
+
+  // Refs so async callbacks (effort fetch) read the freshest settings/commit.
+  const settingsRef = useRef(settings)
+  settingsRef.current = settings
+  const commitRef = useRef(commit)
+  commitRef.current = commit
+
   useEffect(() => {
     let alive = true
     api.settingsGet()
@@ -159,51 +283,123 @@ export function KanbanSettingsSection({ t }: SettingsSectionProps): JSX.Element
     api.models()
       .then((list) => { if (alive) setModels(list) })
       .catch(() => undefined)
+    api.presets()
+      .then((list) => { if (alive) setPresets(list) })
+      .catch(() => undefined)
     return () => { alive = false }
   }, [])
 
-  const commit = async (patch: Partial<KanbanSettingsShape>): Promise<void> => {
-    try {
-      const next = await api.settingsSet(patch)
-      setSettings(next)
-      setSaved(true)
-      window.setTimeout(() => setSaved(false), 1500)
-    } catch {
-      // keep the previous value
+  /** Reasoning routes already requested (dedupe across mount + model changes). */
+  const effortFetched = useRef<Set<string>>(new Set())
+
+  /**
+   * Fetch the reasoning efforts of one model route (once per route). A failed
+   * fetch is marked `failed` so the stored effort is preserved (see the reset
+   * effect below) instead of being wiped by a transient error.
+   */
+  const loadEfforts = useCallback((provider: string, model: string): void => {
+    const key = `${provider}/${model}`
+    if (effortFetched.current.has(key)) return
+    effortFetched.current.add(key)
+    api.reasoningOptions(provider, model)
+      .then((opts) => setEfforts((prev) => ({ ...prev, [key]: opts })))
+      .catch(() => setEfforts((prev) => ({ ...prev, [key]: { efforts: [], failed: true } })))
+  }, [])
+
+  // Fetch efforts for the models already configured in settings, so the
+  // effort selects show their levels (and validate the stored effort) as soon
+  // as settings load — the fetch previously ran only on model change.
+  useEffect(() => {
+    for (const kind of ['refinement', 'phase'] as const) {
+      const fields = GROUP_FIELDS[kind]
+      const model = settings[fields.model]
+      const provider = settings[fields.provider]
+      if (model !== '' && provider !== '') loadEfforts(provider, model)
     }
-  }
+  }, [settings.refinementModel, settings.refinementProvider, settings.phaseModel, settings.phaseProvider, loadEfforts])
+
+  // When the efforts of the selected model arrive, drop a stored effort the
+  // model no longer offers (e.g. the user switched the model). A failed fetch
+  // (`failed: true`) keeps the stored effort: the model may just be
+  // temporarily unresolvable, and wiping the user's choice would be worse.
+  useEffect(() => {
+    const s = settingsRef.current
+    for (const kind of ['refinement', 'phase'] as const) {
+      const fields = GROUP_FIELDS[kind]
+      const model = s[fields.model]
+      const provider = s[fields.provider]
+      const effort = s[fields.effort]
+      if (effort === '' || model === '' || provider === '') continue
+      const opts = efforts[`${provider}/${model}`]
+      if (opts === undefined || opts.failed === true) continue
+      if (!opts.efforts.some((o) => o.id === effort)) {
+        void commitRef.current({ [fields.effort]: '' } as Partial<KanbanSettingsShape>)
+      }
+    }
+  }, [efforts])
 
   return (
-    <div className="kb-settings">
-      <label className="kb-field kb-field-row">
-        <span>{tr('maxParallelWorkers')}</span>
-        <input
-          className="kb-input kb-input-number"
-          type="number"
-          min={1}
-          step={1}
-          value={settings.maxParallelWorkers}
-          onChange={(e) => {
-            const value = Math.max(1, Math.floor(Number(e.target.value) || 1))
-            setSettings((s) => ({ ...s, maxParallelWorkers: value }))
-            void commit({ maxParallelWorkers: value })
-          }}
-        />
-      </label>
-      <label className="kb-field kb-field-row">
-        <span>{tr('defaultModel')}</span>
-        <select
-          className="kb-input"
-          value={settings.defaultModel}
-          onChange={(e) => { void commit({ defaultModel: e.target.value }) }}
-        >
-          <option value="">—</option>
-          {models.map((m) => (
-            <option key={m.provider + '/' + m.id} value={m.id}>{m.name ?? m.id}</option>
-          ))}
-        </select>
-      </label>
-      {saved && <div className="kb-settings-saved">{tr('saved')}</div>}
-    </div>
+    <li className="kb-settings-card" data-open={open ? '' : undefined}>
+      <button
+        type="button"
+        className="kb-settings-card-head"
+        aria-expanded={open}
+        aria-label={(open ? tr('settingsCollapse') : tr('settingsExpand')) + '：' + tr('settingsTitle')}
+        onClick={() => setOpen(!open)}
+      >
+        <span className="kb-settings-card-headText">
+          <span className="kb-settings-card-title">{tr('settingsTitle')}</span>
+          <span className="kb-settings-card-sub">{tr('settingsDescription')}</span>
+        </span>
+        <span className="kb-settings-card-chevron" data-open={open ? '' : undefined} aria-hidden="true">
+          <svg width="14" height="14" viewBox="0 0 14 14" fill="none">
+            <path d="M3.5 5.25L7 8.75L10.5 5.25" stroke="currentColor" strokeWidth="1.5"
+              strokeLinecap="round" strokeLinejoin="round" />
+          </svg>
+        </span>
+      </button>
+      {open && (
+        <div className="kb-settings-card-body">
+          <div className="kb-settings">
+            <label className="kb-field kb-field-row">
+              <span>{tr('maxParallelWorkers')}</span>
+              <input
+                className="kb-input kb-input-number"
+                type="number"
+                min={1}
+                step={1}
+                value={settings.maxParallelWorkers}
+                onChange={(e) => {
+                  const value = Math.max(1, Math.floor(Number(e.target.value) || 1))
+                  setSettings((s) => ({ ...s, maxParallelWorkers: value }))
+                  void commit({ maxParallelWorkers: value })
+                }}
+              />
+            </label>
+            <SessionDefaultsGroup
+              kind="refinement"
+              settings={settings}
+              models={models}
+              presets={presets}
+              efforts={efforts}
+              tr={tr}
+              onCommit={commit}
+              loadEfforts={loadEfforts}
+            />
+            <SessionDefaultsGroup
+              kind="phase"
+              settings={settings}
+              models={models}
+              presets={presets}
+              efforts={efforts}
+              tr={tr}
+              onCommit={commit}
+              loadEfforts={loadEfforts}
+            />
+            {saved && <div className="kb-settings-saved">{tr('saved')}</div>}
+          </div>
+        </div>
+      )}
+    </li>
   )
 }

package/src/server/models.ts

@@ -18,3 +18,43 @@ export async function listModels(ctx: Context): Promise<ModelOption[]> {
   }
   return out
 }
+
+/** One selectable reasoning effort of a model (display vocabulary for the settings picker). */
+export interface ReasoningEffortOption {
+  id: string
+  name: string
+  description?: string
+}
+
+export interface ReasoningOptions {
+  efforts: ReasoningEffortOption[]
+  defaultEffort?: string
+}
+
+/**
+ * Resolve the adapter-owned reasoning efforts of one exact provider/model
+ * route. On-demand (one model at a time) so the settings picker can offer the
+ * levels the selected model actually supports; failures yield an empty list.
+ */
+export async function reasoningOptions(ctx: Context, provider: string, model: string): Promise<ReasoningOptions> {
+  const llm = ctx.get('llm') as
+    | { resolveModelInfo(provider: string, model: string, signal?: AbortSignal): Promise<{
+      reasoning?: { efforts?: Array<{ id: unknown; name: string; description?: string }>; defaultEffort?: unknown }
+    }> }
+    | undefined
+  if (llm === undefined) return { efforts: [] }
+  try {
+    const info = await llm.resolveModelInfo(provider, model)
+    const efforts = (info.reasoning?.efforts ?? []).map((e) => ({
+      id: String(e.id),
+      name: e.name,
+      ...(e.description !== undefined ? { description: e.description } : {}),
+    }))
+    return {
+      efforts,
+      ...(info.reasoning?.defaultEffort !== undefined ? { defaultEffort: String(info.reasoning.defaultEffort) } : {}),
+    }
+  } catch {
+    return { efforts: [] }
+  }
+}

package/src/server/rpc.ts

@@ -6,10 +6,10 @@
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import type { Context } from '@deepseek-ai/cordis'
 import type {} from '@deepseek-ai/dsh-host-webserver'
-import type { Lane } from '../shared/card.js'
+import type { KanbanSettingsShape, Lane } from '../shared/card.js'
 import type { KanbanRunner } from './runner.js'
 import type { KanbanSettingsFace } from './settings.js'
-import { listModels } from './models.js'
+import { listModels, reasoningOptions } from './models.js'
 
 const API_PREFIX = '/plugins/@fonlan/dsh-task-kanban/api'
 
@@ -152,16 +152,45 @@ export function registerApiRoutes(
 
   route('settings.get', async () => settings.get())
 
+  /** Every settings field the client may write (per-session-type defaults included). */
+  const SETTING_STRING_FIELDS = [
+    'refinementModel',
+    'refinementProvider',
+    'refinementReasoningEffort',
+    'refinementPreset',
+    'phaseModel',
+    'phaseProvider',
+    'phaseReasoningEffort',
+    'phasePreset',
+  ] as const
+
   route('settings.set', async (p) => {
-    const patch: { maxParallelWorkers?: number; defaultModel?: string } = {}
+    const patch: Partial<KanbanSettingsShape> = {}
     if (typeof p.maxParallelWorkers === 'number') patch.maxParallelWorkers = p.maxParallelWorkers
-    if (typeof p.defaultModel === 'string') patch.defaultModel = p.defaultModel
+    for (const key of SETTING_STRING_FIELDS) {
+      if (typeof p[key] === 'string') patch[key] = p[key]
+    }
     await settings.update(patch)
     return settings.get()
   })
 
   route('models.list', async () => listModels(ctx))
 
+  route('presets.list', async () => {
+    const presets = ctx.get('agentPresets') as
+      | { list(): Promise<Array<{ id: string; name?: string; description?: string }>> }
+      | undefined
+    if (presets === undefined) return []
+    const rows = await presets.list()
+    return rows.map((r) => ({ id: r.id, name: r.name, description: r.description }))
+  })
+
+  route('reasoning.options', async (p) => {
+    const provider = requireString(p.provider, 'provider')
+    const model = requireString(p.model, 'model')
+    return reasoningOptions(ctx, provider, model)
+  })
+
   return () => {
     for (const d of disposers) d()
   }

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'
@@ -425,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) => {
@@ -434,7 +434,7 @@ export class KanbanRunner implements KanbanToolResolver {
       c.sessions.refinement.push(sessionId)
     }, wsPath)
     try {
-      const handle = await this.createAgent(sessionId, wsPath, route)
+      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
@@ -556,18 +556,54 @@ 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 },
+    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
@@ -577,10 +613,13 @@ export class KanbanRunner implements KanbanToolResolver {
           | { 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')
         }
+        if (selectionRef.current !== undefined && selectionRef.current.reasoningEffort !== undefined) {
+          installModelSelection(agentCtx, selectionRef)
+        }
       },
     })
   }
@@ -619,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 !== '') {
@@ -630,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()
   }
@@ -731,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)
+      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)))
@@ -984,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)
+      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()