@fonlan/dsh-task-kanban 0.1.1 → 0.2.0

package/src/client/board.css

@@ -21,14 +21,20 @@
 .kb-board-header {
   display: flex;
   align-items: center;
-  justify-content: space-between;
   gap: 12px;
   padding-bottom: 10px;
   border-bottom: 1px solid rgba(128, 128, 128, 0.25);
   flex: 0 0 auto;
 }
-.kb-board-actions { display: flex; gap: 8px; align-items: center; flex: none; }
-.kb-board-actions .kb-btn { flex: none; }
+/* Left-aligned group: workspace selector + new-task button sit adjacent. */
+.kb-board-title {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+  flex: 0 1 auto;
+}
+.kb-board-title .kb-btn { flex: none; }
 .kb-ws-select {
   max-width: 320px;
   min-width: 0;
@@ -302,16 +308,46 @@
 .kb-status-error { background: rgba(239, 68, 68, 0.3) !important; color: #f87171; }
 .kb-status-merged { background: rgba(34, 197, 94, 0.3) !important; }
 .kb-plan-summary { font-size: 13px; margin-bottom: 10px; }
-.kb-plan-phases { margin: 0; padding-left: 20px; }
-.kb-plan-phase { margin-bottom: 10px; }
-.kb-plan-phase-current .kb-plan-phase-title { color: #60a5fa; }
-.kb-plan-phase-head { display: flex; gap: 8px; align-items: baseline; }
+/* Phase cards: each plan phase is a card with an ordered number (kept from the
+   parent <ol>) and three labeled sections (goal / sessions / conclusion) split
+   by section titles and thin divider lines. */
+.kb-plan-phases { margin: 0; padding-left: 24px; }
+.kb-plan-phase {
+  margin-bottom: 10px;
+  padding: 8px 10px;
+  background: rgba(128, 128, 128, 0.08);
+  border: 1px solid rgba(128, 128, 128, 0.2);
+  border-radius: 8px;
+}
+.kb-plan-phase-head {
+  display: flex;
+  gap: 8px;
+  align-items: baseline;
+  padding-bottom: 6px;
+  margin-bottom: 6px;
+  border-bottom: 1px solid rgba(128, 128, 128, 0.16);
+}
 .kb-plan-phase-title { font-weight: 600; font-size: 13px; }
 .kb-plan-phase-id { font-size: 11px; opacity: 0.5; }
-.kb-plan-phase-goal { font-size: 12px; opacity: 0.85; margin: 2px 0 6px; white-space: pre-wrap; }
+.kb-plan-phase-body { display: flex; flex-direction: column; }
+/* Section isolation: label on top, thin divider between adjacent sections. */
+.kb-plan-phase-section { display: flex; flex-direction: column; }
+.kb-plan-phase-section + .kb-plan-phase-section {
+  margin-top: 6px;
+  padding-top: 6px;
+  border-top: 1px solid rgba(128, 128, 128, 0.14);
+}
+.kb-plan-phase-section-title { font-size: 11px; opacity: 0.55; margin-bottom: 3px; }
+.kb-plan-phase-goal { font-size: 12px; opacity: 0.85; white-space: pre-wrap; word-break: break-all; }
+.kb-plan-phase-sessions { display: flex; flex-wrap: wrap; gap: 6px; align-items: center; }
+.kb-plan-phase-conclusion { font-size: 12px; opacity: 0.85; white-space: pre-wrap; word-break: break-all; }
+.kb-plan-phase-conclusion-item + .kb-plan-phase-conclusion-item { margin-top: 6px; }
+/* Running phase keeps the blue highlight; completed phases get success color. */
+.kb-plan-phase-current { border-color: rgba(59, 130, 246, 0.6); background: rgba(59, 130, 246, 0.08); }
+.kb-plan-phase-current .kb-plan-phase-title { color: #60a5fa; }
+.kb-plan-phase-completed { border-color: rgba(34, 197, 94, 0.45); background: rgba(34, 197, 94, 0.06); }
+.kb-plan-phase-completed .kb-plan-phase-title { color: #4ade80; }
 .kb-session-links { display: flex; flex-wrap: wrap; gap: 6px; align-items: center; }
-.kb-session-attempt { display: flex; gap: 6px; align-items: center; flex-wrap: wrap; }
-.kb-session-summary { font-size: 12px; opacity: 0.75; }
 .kb-settings { display: flex; flex-direction: column; gap: 12px; max-width: 420px; }
 .kb-settings-saved { font-size: 12px; color: #4ade80; }
 .kb-footer-action {

package/src/client/board.tsx

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import type { KanbanCard, Lane } from '../shared/card'
+import type { KanbanCard, Lane, PhaseAttempt, PlanPhase } from '../shared/card'
 import { DROP_RULES, laneOf } from '../shared/lanes'
 import { api, gatewaySkillList, type SkillOption } from './api'
 import { exitBoard, getClient } from './kanban-state'
@@ -189,8 +189,6 @@ export function BoardRoot(props: BoardProps): JSX.Element {
               <option key={w.workspaceId} value={w.path}>{w.title}</option>
             ))}
           </select>
-        </div>
-        <div className="kb-board-actions">
           <button type="button" className="kb-btn kb-btn-primary" onClick={() => setNewTaskOpen(true)}>{t('newTask')}</button>
         </div>
       </div>
@@ -564,14 +562,14 @@ function DetailPanel({ card, t, onClose, onChanged, onToast, onOpenSession }: De
               <div className="kb-plan-summary">{card.plan.summary}</div>
               <ol className="kb-plan-phases">
                 {card.plan.phases.map((phase, i) => (
-                  <li key={phase.id} className={'kb-plan-phase' + (i === card.currentPhase && card.status === 'running' ? ' kb-plan-phase-current' : '')}>
-                    <div className="kb-plan-phase-head">
-                      <span className="kb-plan-phase-title">{phase.title}</span>
-                      <span className="kb-plan-phase-id">{phase.id}</span>
-                    </div>
-                    <div className="kb-plan-phase-goal">{phase.goal}</div>
-                    <PhaseSessions phaseIndex={i} card={card} t={t} onOpenSession={onOpenSession} />
-                  </li>
+                  <PhaseCard
+                    key={phase.id}
+                    phase={phase}
+                    phaseIndex={i}
+                    card={card}
+                    t={t}
+                    onOpenSession={onOpenSession}
+                  />
                 ))}
               </ol>
             </div>
@@ -628,23 +626,68 @@ function DetailPanel({ card, t, onClose, onChanged, onToast, onOpenSession }: De
   )
 }
 
-function PhaseSessions({ phaseIndex, card, t, onOpenSession }: {
+/** One plan phase rendered as a card with goal / sessions / conclusion sections. */
+function PhaseCard({ phase, phaseIndex, card, t, onOpenSession }: {
+  phase: PlanPhase
   phaseIndex: number
   card: KanbanCard
-  t: (key: string) => string
+  t: (key: string, params?: Record<string, unknown>) => string
   onOpenSession: (sessionId: string) => void
-}): JSX.Element | null {
+}): JSX.Element {
   const attempts = card.sessions.phases.filter((a) => a.phaseIndex === phaseIndex)
-  if (attempts.length === 0) return null
+  const summaries = attempts
+    .filter((a) => a.summary !== undefined && a.summary.trim() !== '')
+    .map((a) => a.summary as string)
+  const isCurrent = phaseIndex === card.currentPhase && card.status === 'running'
+  // A phase with at least one concluded attempt counts as completed.
+  const isCompleted = summaries.length > 0
+  const cls = 'kb-plan-phase'
+    + (isCurrent ? ' kb-plan-phase-current' : '')
+    + (isCompleted ? ' kb-plan-phase-completed' : '')
+  return (
+    <li className={cls}>
+      <div className="kb-plan-phase-head">
+        <span className="kb-plan-phase-title">{phase.title}</span>
+        <span className="kb-plan-phase-id">{phase.id}</span>
+      </div>
+      <div className="kb-plan-phase-body">
+        <div className="kb-plan-phase-section">
+          <div className="kb-plan-phase-section-title">{t('phaseGoal')}</div>
+          <div className="kb-plan-phase-goal">{phase.goal}</div>
+        </div>
+        {attempts.length > 0 && (
+          <div className="kb-plan-phase-section">
+            <div className="kb-plan-phase-section-title">{t('phaseSessions')}</div>
+            <PhaseSessions attempts={attempts} t={t} onOpenSession={onOpenSession} />
+          </div>
+        )}
+        {summaries.length > 0 && (
+          <div className="kb-plan-phase-section">
+            <div className="kb-plan-phase-section-title">{t('phaseConclusion')}</div>
+            <div className="kb-plan-phase-conclusion">
+              {summaries.map((s, idx) => (
+                <div key={idx} className="kb-plan-phase-conclusion-item">{s}</div>
+              ))}
+            </div>
+          </div>
+        )}
+      </div>
+    </li>
+  )
+}
+
+/** Open-session buttons for one phase's attempts (retries append more). */
+function PhaseSessions({ attempts, t, onOpenSession }: {
+  attempts: PhaseAttempt[]
+  t: (key: string) => string
+  onOpenSession: (sessionId: string) => void
+}): JSX.Element {
   return (
-    <div className="kb-session-links">
+    <div className="kb-plan-phase-sessions">
       {attempts.map((a) => (
-        <span key={a.sessionId} className="kb-session-attempt">
-          <button type="button" className="kb-btn kb-btn-small" onClick={() => onOpenSession(a.sessionId)}>
-            {t('openSession')} · {a.sessionId.slice(0, 13)}
-          </button>
-          {a.summary !== undefined && <span className="kb-session-summary">{a.summary}</span>}
-        </span>
+        <button key={a.sessionId} type="button" className="kb-btn kb-btn-small" onClick={() => onOpenSession(a.sessionId)}>
+          {t('openSession')} · {a.sessionId.slice(0, 13)}
+        </button>
       ))}
     </div>
   )

package/src/client/locales.ts

@@ -38,6 +38,9 @@ export const zh = {
   plan: '实现方案',
   summary: '摘要',
   phases: '阶段',
+  phaseGoal: '目标',
+  phaseSessions: '会话',
+  phaseConclusion: '结论',
   error: '错误',
   requirementLabel: '需求文本',
   requirementPlaceholder: '描述你要实现的需求……',
@@ -48,7 +51,7 @@ export const zh = {
   modelPlaceholder: '（使用默认模型）',
   noWorkspace: '没有可用工作区，请先在侧边栏添加',
   refresh: '刷新',
-  settingsTitle: '任务看板设置',
+  settingsTitle: '任务看板',
   maxParallelWorkers: '全局并行 worker 数',
   defaultModel: '默认模型',
   saved: '已保存',
@@ -103,6 +106,9 @@ export const en = {
   plan: 'Plan',
   summary: 'Summary',
   phases: 'Phases',
+  phaseGoal: 'Goal',
+  phaseSessions: 'Sessions',
+  phaseConclusion: 'Conclusion',
   error: 'Error',
   requirementLabel: 'Requirement',
   requirementPlaceholder: 'Describe what you want to build…',
@@ -113,7 +119,7 @@ export const en = {
   modelPlaceholder: '(use default model)',
   noWorkspace: 'No workspaces available — add one in the sidebar first',
   refresh: 'Refresh',
-  settingsTitle: 'Task Kanban Settings',
+  settingsTitle: 'Task Kanban',
   maxParallelWorkers: 'Global parallel workers',
   defaultModel: 'Default model',
   saved: 'Saved',

package/src/server/runner.ts

@@ -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) {
@@ -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)
       this.keepHandle(cardId, handle)
       await this.attachRefinementSession(wsPath, sessionId)
       // The agent scope is the layer where preset skill providers live
@@ -466,7 +560,6 @@ export class KanbanRunner implements KanbanToolResolver {
     sessionId: SessionId,
     cwd: string,
     route: { provider?: string; model?: string },
-    resolver: KanbanToolResolver,
   ) {
     const agentOptions =
       route.provider !== undefined && route.model !== undefined && route.model !== ''
@@ -476,6 +569,9 @@ export class KanbanRunner implements KanbanToolResolver {
       sessionId,
       meta: { cwd },
       ...(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> }
@@ -485,7 +581,6 @@ export class KanbanRunner implements KanbanToolResolver {
         } else {
           throw new Error('@fonlan/dsh-task-kanban: agent-presets service is not mounted')
         }
-        registerKanbanTools(agentCtx, resolver)
       },
     })
   }
@@ -638,7 +733,7 @@ export class KanbanRunner implements KanbanToolResolver {
     }, wsPath)
     const route = await this.modelRoute(cardId, wsPath)
     try {
-      const handle = await this.createAgent(sessionId, workdir, route, this.toolResolver())
+      const handle = await this.createAgent(sessionId, workdir, route)
       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)))
@@ -891,7 +986,7 @@ export class KanbanRunner implements KanbanToolResolver {
     await this.store.mutate(cardId, (c) => { c.sessions.merge.push(sessionId) }, wsPath)
     const route = await this.modelRoute(cardId, wsPath)
     try {
-      const handle = await this.createAgent(sessionId, workdir, route, this.toolResolver())
+      const handle = await this.createAgent(sessionId, workdir, route)
       this.keepHandle(cardId, handle)
       handle.agent.followup(this.asUserMessage(mergePrompt(workdir, conflicts)))
       await handle.agent.whenIdle()