popilot 0.6.0 → 0.8.0

package/scaffold/pm-api/src/mcp-tools/memo.ts

@@ -0,0 +1,164 @@
+import { query, execute } from '../db/adapter.js'
+import { text, err, today, resolveSprint, notify, checkRateLimit, emitAgentEvent, validateAssignee, resolveMemberId, type ToolResult } from './utils.js'
+
+export async function toolSendMemo(user: string, args: Record<string, unknown>): Promise<ToolResult> {
+  const toUserRaw = args.to_user as string
+  const recipients = toUserRaw.split(',').map(s => s.trim()).filter(Boolean)
+  const assignedTo = recipients.join(',')
+  const content = args.content as string
+  const pageId = (args.page_id as string) || 'home'
+  const memoType = (args.memo_type as string) || 'memo'
+  const preview = content.length > 50 ? content.slice(0, 50) + '…' : content
+
+  // Parse [D-XX] tags → related_decisions
+  const decisionMatches = content.match(/\[D-\d+\]/g)
+  const relatedDecisions = decisionMatches ? JSON.stringify([...new Set(decisionMatches.map(m => m.slice(1, -1)))]) : null
+  const reviewRequired = (args.review_required as boolean) ? 1 : 0
+  const title = (args.title as string) ?? null
+  const supersedesId = (args.supersedes_id as number) ?? null
+
+  // Decision type requires title
+  if (memoType === 'decision' && !title) {
+    return err('Decision type memos require a title.')
+  }
+
+  // Supersede: update previous memo status
+  if (supersedesId) {
+    await execute('UPDATE memos_v2 SET status = ? WHERE id = ?', ['superseded', supersedesId])
+  }
+
+  // Resolve member IDs
+  const createdById = await resolveMemberId(user)
+  const assignedToId = recipients.length === 1 ? await resolveMemberId(recipients[0]) : null
+
+  const result = await execute(
+    'INSERT INTO memos_v2 (page_id, content, memo_type, created_by, created_by_id, assigned_to, assigned_to_id, related_decisions, review_required, title, supersedes_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
+    [pageId, content, memoType, user, createdById, assignedTo, assignedToId, relatedDecisions, reviewRequired, title, supersedesId],
+  )
+  if (result.error) return err(result.error)
+
+  const idResult = await query<{ id: number }>('SELECT last_insert_rowid() as id')
+  const memoId = idResult.rows[0]?.id ?? 0
+
+  // Notify each recipient
+  for (const r of recipients) {
+    await notify(r, 'memo_received', `New memo: ${user}`, preview, 'memo', memoId, pageId, user)
+  }
+
+  // Auto-emit agent events
+  for (const r of recipients) {
+    await emitAgentEvent('memo_assigned', user, r, r, {
+      memo_id: memoId, from: user, preview, page_id: pageId,
+    })
+  }
+
+  // Agent webhook notification
+  const { notifyByName } = await import('../utils/agent-notify.js')
+  for (const r of recipients) {
+    await notifyByName(r, `📋 New memo: ${user}`, `${preview}\n\nMemo #${memoId} | ${memoType}`)
+  }
+
+  return text(`✅ Memo sent: ${user} → ${assignedTo}`)
+}
+
+export async function toolListMemos(user: string, args: Record<string, unknown>): Promise<ToolResult> {
+  let sql = "SELECT * FROM memos_v2 WHERE (assigned_to = ? OR assigned_to LIKE ? OR assigned_to LIKE ? OR assigned_to LIKE ?)"
+  const sqlArgs: (string | number)[] = [user, `${user},%`, `%,${user},%`, `%,${user}`]
+  if (args.unread_only) { sql += " AND status = 'open'" }
+  sql += ' ORDER BY created_at DESC LIMIT 20'
+
+  const result = await query<{ id: number; page_id: string; content: string; memo_type: string; status: string; created_by: string; assigned_to: string | null; created_at: string }>(sql, sqlArgs)
+  if (result.error) return err(result.error)
+  if (result.rows.length === 0) return text('📩 No memos found.')
+
+  const lines = [`📩 ${user}'s Memos`, '─────────────']
+  for (const m of result.rows) {
+    const icon = m.status === 'open' ? '📩' : m.status === 'resolved' ? '✅' : '📖'
+    const preview = m.content.length > 60 ? m.content.slice(0, 60) + '…' : m.content
+    lines.push(`${icon} [M${m.id}] ${m.created_by} (${m.page_id}): ${preview}`)
+  }
+  return text(lines.join('\n'))
+}
+
+export async function toolReadMemo(args: Record<string, unknown>): Promise<ToolResult> {
+  const memoId = args.memo_id as number
+  const result = await query<{ id: number; page_id: string; content: string; memo_type: string; status: string; created_by: string; assigned_to: string | null; resolved_by: string | null; resolved_at: string | null; created_at: string }>('SELECT * FROM memos_v2 WHERE id = ?', [memoId])
+  if (result.error) return err(result.error)
+  if (result.rows.length === 0) return err(`Memo #${memoId} not found.`)
+
+  const m = result.rows[0]
+
+  const repliesResult = await query<{ id: number; content: string; created_by: string; created_at: string }>('SELECT * FROM memo_replies WHERE memo_id = ? ORDER BY created_at ASC', [memoId])
+
+  const lines = [`📩 Memo #${m.id}`, '─────────────', `From: ${m.created_by} → ${m.assigned_to ?? 'all'}`, `Page: ${m.page_id}`, `Status: ${m.status}`, `Date: ${m.created_at}`, '', m.content]
+  if (m.resolved_by) lines.push('', `✅ Resolved: ${m.resolved_by} (${m.resolved_at})`)
+  if (!repliesResult.error && repliesResult.rows.length > 0) {
+    lines.push('', '💬 Replies:')
+    for (const r of repliesResult.rows) lines.push(`  ${r.created_by} (${r.created_at}): ${r.content}`)
+  }
+  return text(lines.join('\n'))
+}
+
+export async function toolReplyMemo(user: string, args: Record<string, unknown>): Promise<ToolResult> {
+  const memoId = args.memo_id as number
+  const content = args.content as string
+  const reviewType = (args.review_type as string) || 'comment'
+  const result = await execute(
+    'INSERT INTO memo_replies (memo_id, content, created_by, review_type) VALUES (?, ?, ?, ?)',
+    [memoId, content, user, reviewType],
+  )
+  if (result.error) return err(result.error)
+
+  // Notify memo author
+  const memoResult = await query<{ created_by: string; assigned_to: string | null }>(
+    'SELECT created_by, assigned_to FROM memos_v2 WHERE id = ?', [memoId],
+  )
+  if (!memoResult.error && memoResult.rows.length > 0) {
+    const memo = memoResult.rows[0]
+    const preview = content.length > 50 ? content.slice(0, 50) + '…' : content
+    // Notify author
+    await notify(memo.created_by, 'memo_reply', `Memo reply: ${user}`, preview, 'memo', memoId, 'home', user)
+    // If assigned_to is different from author and from replier, notify them too
+    if (memo.assigned_to && memo.assigned_to !== memo.created_by && memo.assigned_to !== user) {
+      await notify(memo.assigned_to, 'memo_reply', `Memo reply: ${user}`, preview, 'memo', memoId, 'home', user)
+    }
+    // Auto-emit agent event
+    await emitAgentEvent('memo_replied', user, memo.created_by, memo.created_by, {
+      memo_id: memoId, reply_by: user, preview,
+    })
+  }
+
+  return text(`✅ Reply sent to Memo #${memoId}`)
+}
+
+export async function toolResolveMemo(user: string, args: Record<string, unknown>): Promise<ToolResult> {
+  const memoId = args.memo_id as number
+  const result = await execute(
+    `UPDATE memos_v2 SET status = 'resolved', resolved_by = ?, resolved_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP WHERE id = ?`,
+    [user, memoId],
+  )
+  if (result.error) return err(result.error)
+  if (result.rowsAffected === 0) return err(`Memo #${memoId} not found.`)
+
+  // Notify memo author
+  const memoResult = await query<{ created_by: string }>(
+    'SELECT created_by FROM memos_v2 WHERE id = ?', [memoId],
+  )
+  if (!memoResult.error && memoResult.rows.length > 0) {
+    await notify(memoResult.rows[0].created_by, 'memo_resolved', `Memo resolved: ${user}`, `${user} resolved Memo #${memoId}.`, 'memo', memoId, 'home', user)
+    // Auto-emit agent event
+    await emitAgentEvent('memo_resolved', user, memoResult.rows[0].created_by, memoResult.rows[0].created_by, {
+      memo_id: memoId, resolved_by: user,
+    })
+  }
+
+  return text(`✅ Memo #${memoId} resolved`)
+}
+
+export async function toolRejectMemo(args: Record<string, unknown>): Promise<ToolResult> {
+  const memoId = args.memo_id as number
+  if (!memoId) return err('memo_id required')
+  const r = await execute("UPDATE memos_v2 SET status = 'open', resolved_by = NULL, resolved_at = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?", [memoId])
+  if (r.error) return err(r.error)
+  return text(`✅ Memo #${memoId} rejected (reopened)`)
+}

package/scaffold/pm-api/src/mcp-tools/notification.ts

@@ -0,0 +1,37 @@
+import { query, execute } from '../db/adapter.js'
+import { text, err, today, resolveSprint, notify, checkRateLimit, emitAgentEvent, validateAssignee, resolveMemberId, type ToolResult } from './utils.js'
+
+export async function toolCheckNotifications(user: string, args: Record<string, unknown>): Promise<ToolResult> {
+  const unreadOnly = args.unread_only as boolean | undefined
+  let sql = 'SELECT * FROM notifications WHERE user_name = ?'
+  const sqlArgs: (string | number)[] = [user]
+  if (unreadOnly) { sql += ' AND is_read = 0' }
+  sql += ' ORDER BY created_at DESC LIMIT 30'
+
+  const result = await query<{ id: number; type: string; title: string; body: string | null; source_type: string; source_id: string; actor: string; is_read: number; created_at: string }>(sql, sqlArgs)
+  if (result.error) return err(result.error)
+  if (result.rows.length === 0) return text(unreadOnly ? '🔔 No unread notifications.' : '🔔 No notifications.')
+
+  const unread = result.rows.filter(n => !n.is_read).length
+  const lines = [`🔔 Notifications (${unread} unread)`, '─────────────']
+  for (const n of result.rows) {
+    const icon = n.is_read ? '  ' : '🔴'
+    const body = n.body ? ` — ${n.body.length > 40 ? n.body.slice(0, 40) + '…' : n.body}` : ''
+    lines.push(`${icon} [N${n.id}] ${n.title}${body} (${n.actor}, ${n.created_at.slice(5, 16)})`)
+  }
+  return text(lines.join('\n'))
+}
+
+export async function toolMarkNotificationRead(args: Record<string, unknown>): Promise<ToolResult> {
+  const notifId = args.notification_id as number
+  const result = await execute('UPDATE notifications SET is_read = 1 WHERE id = ?', [notifId])
+  if (result.error) return err(result.error)
+  if (result.rowsAffected === 0) return err(`Notification #${notifId} not found.`)
+  return text(`✅ Notification #${notifId} marked as read`)
+}
+
+export async function toolMarkAllNotificationsRead(user: string): Promise<ToolResult> {
+  const result = await execute('UPDATE notifications SET is_read = 1 WHERE user_name = ? AND is_read = 0', [user])
+  if (result.error) return err(result.error)
+  return text(`✅ ${result.rowsAffected} notifications marked as read.`)
+}

package/scaffold/pm-api/src/mcp-tools/retro.ts

@@ -0,0 +1,183 @@
+import { query, execute } from '../db/adapter.js'
+import { text, err, today, resolveSprint, notify, checkRateLimit, emitAgentEvent, validateAssignee, resolveMemberId, type ToolResult } from './utils.js'
+
+export async function toolGetRetroSession(user: string, args: Record<string, unknown>): Promise<ToolResult> {
+  const sprint = await resolveSprint(args.sprint as string | undefined)
+  if (!sprint) return err('Please specify a sprint.')
+
+  const sessionResult = await query<{ id: number; sprint: string; title: string; phase: string; created_at: string }>(
+    'SELECT * FROM retro_sessions WHERE sprint = ? LIMIT 1', [sprint],
+  )
+  if (sessionResult.error) return err(sessionResult.error)
+  if (sessionResult.rows.length === 0) return text(`${sprint.toUpperCase()} retro session not found.`)
+
+  const session = sessionResult.rows[0]
+  const [itemsResult, actionsResult] = await Promise.all([
+    query<{ id: number; category: string; content: string; author: string; vote_count: number; has_voted: number }>(
+      `SELECT i.*, COUNT(v.item_id) as vote_count,
+       CASE WHEN SUM(CASE WHEN v.voter = ? THEN 1 ELSE 0 END) > 0 THEN 1 ELSE 0 END as has_voted
+       FROM retro_items i LEFT JOIN retro_votes v ON v.item_id = i.id
+       WHERE i.session_id = ? GROUP BY i.id ORDER BY vote_count DESC`,
+      [user, session.id],
+    ),
+    query<{ id: number; content: string; assignee: string | null; status: string }>(
+      'SELECT * FROM retro_actions WHERE session_id = ? ORDER BY created_at ASC',
+      [session.id],
+    ),
+  ])
+
+  const catIcon: Record<string, string> = { keep: '💚', problem: '🔴', try: '💡' }
+  const lines = [
+    `🔄 Retrospective: ${session.title} (${sprint.toUpperCase()})`,
+    `Phase: ${session.phase} | Created: ${session.created_at}`,
+    '─────────────',
+  ]
+
+  if (!itemsResult.error && itemsResult.rows.length > 0) {
+    for (const cat of ['keep', 'problem', 'try']) {
+      const items = itemsResult.rows.filter(i => i.category === cat)
+      if (items.length > 0) {
+        lines.push(`\n${catIcon[cat] ?? '●'} ${cat.toUpperCase()} (${items.length} items)`)
+        for (const i of items) {
+          const voted = i.has_voted ? '★' : '☆'
+          lines.push(`  ${voted} [R${i.id}] ${i.content} (${i.author}, ${i.vote_count} votes)`)
+        }
+      }
+    }
+  } else {
+    lines.push('\nNo items found.')
+  }
+
+  if (!actionsResult.error && actionsResult.rows.length > 0) {
+    const si: Record<string, string> = { todo: '⬜', 'in-progress': '🔵', done: '✅' }
+    lines.push('\n📌 Action Items:')
+    for (const a of actionsResult.rows) {
+      lines.push(`  ${si[a.status] ?? '⬜'} [A${a.id}] ${a.content} (${a.assignee ?? 'Unassigned'})`)
+    }
+  }
+
+  return text(lines.join('\n'))
+}
+
+export async function toolAddRetroItem(user: string, args: Record<string, unknown>): Promise<ToolResult> {
+  const sessionId = args.session_id as number
+  const category = args.category as string
+  const content = args.content as string
+
+  const result = await execute(
+    'INSERT INTO retro_items (session_id, category, content, author) VALUES (?, ?, ?, ?)',
+    [sessionId, category, content, user],
+  )
+  if (result.error) return err(result.error)
+  return text(`✅ Retro item added (${category}): ${content}`)
+}
+
+export async function toolVoteRetroItem(user: string, args: Record<string, unknown>): Promise<ToolResult> {
+  const itemId = args.item_id as number
+
+  // Check if already voted
+  const existing = await query<{ item_id: number }>(
+    'SELECT item_id FROM retro_votes WHERE item_id = ? AND voter = ?', [itemId, user],
+  )
+  if (existing.rows.length > 0) {
+    await execute('DELETE FROM retro_votes WHERE item_id = ? AND voter = ?', [itemId, user])
+    return text(`✅ Vote removed: item #${itemId}`)
+  } else {
+    await execute('INSERT OR IGNORE INTO retro_votes (item_id, voter) VALUES (?, ?)', [itemId, user])
+    return text(`✅ Voted: item #${itemId}`)
+  }
+}
+
+export async function toolChangeRetroPhase(args: Record<string, unknown>): Promise<ToolResult> {
+  const sessionId = args.session_id as number
+  const phase = args.phase as string
+  const result = await execute(
+    'UPDATE retro_sessions SET phase = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
+    [phase, sessionId],
+  )
+  if (result.error) return err(result.error)
+  if (result.rowsAffected === 0) return err(`Session #${sessionId} not found.`)
+  return text(`✅ Retro session #${sessionId} → ${phase} phase`)
+}
+
+export async function toolAddRetroAction(user: string, args: Record<string, unknown>): Promise<ToolResult> {
+  const sessionId = args.session_id as number
+  const content = args.content as string
+  const assignee = (args.assignee as string) ?? null
+
+  const result = await execute(
+    'INSERT INTO retro_actions (session_id, content, assignee) VALUES (?, ?, ?)',
+    [sessionId, content, assignee],
+  )
+  if (result.error) return err(result.error)
+
+  // Notify assignee
+  if (assignee) {
+    const idResult = await query<{ id: number }>('SELECT last_insert_rowid() as id')
+    const actionId = idResult.rows[0]?.id ?? 0
+    await notify(assignee, 'retro_action', `Retro action assigned: ${content.slice(0, 30)}`, `${user} assigned retro action: ${content}`, 'retro_action', actionId, 'retro', user)
+  }
+
+  return text(`✅ Action added: ${content}${assignee ? ` (assignee: ${assignee})` : ''}`)
+}
+
+export async function toolUpdateRetroActionStatus(args: Record<string, unknown>): Promise<ToolResult> {
+  const actionId = args.action_id as number
+  const status = args.status as string
+  const result = await execute(
+    'UPDATE retro_actions SET status = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
+    [status, actionId],
+  )
+  if (result.error) return err(result.error)
+  if (result.rowsAffected === 0) return err(`Action #${actionId} not found.`)
+  return text(`✅ Action #${actionId} → ${status}`)
+}
+
+export async function toolExportRetro(args: Record<string, unknown>): Promise<ToolResult> {
+  const sprint = await resolveSprint(args.sprint as string | undefined)
+  if (!sprint) return err('Please specify a sprint.')
+
+  const sessionResult = await query<{ id: number; title: string; phase: string }>(
+    'SELECT id, title, phase FROM retro_sessions WHERE sprint = ? LIMIT 1', [sprint],
+  )
+  if (sessionResult.error) return err(sessionResult.error)
+  if (sessionResult.rows.length === 0) return err(`${sprint.toUpperCase()} retro session not found.`)
+
+  const session = sessionResult.rows[0]
+  const [itemsResult, actionsResult] = await Promise.all([
+    query<{ category: string; content: string; author: string; vote_count: number }>(
+      `SELECT i.category, i.content, i.author, COUNT(v.item_id) as vote_count
+       FROM retro_items i LEFT JOIN retro_votes v ON v.item_id = i.id
+       WHERE i.session_id = ? GROUP BY i.id ORDER BY i.category, vote_count DESC`,
+      [session.id],
+    ),
+    query<{ content: string; assignee: string | null; status: string }>(
+      'SELECT content, assignee, status FROM retro_actions WHERE session_id = ? ORDER BY created_at',
+      [session.id],
+    ),
+  ])
+
+  const lines = [
+    `# ${session.title} (${sprint.toUpperCase()})`,
+    '',
+  ]
+
+  if (!itemsResult.error) {
+    for (const cat of ['keep', 'problem', 'try']) {
+      const items = itemsResult.rows.filter(i => i.category === cat)
+      lines.push(`## ${cat.toUpperCase()} (${items.length} items)`)
+      for (const i of items) lines.push(`- ${i.content} — ${i.author} (${i.vote_count} votes)`)
+      lines.push('')
+    }
+  }
+
+  if (!actionsResult.error && actionsResult.rows.length > 0) {
+    lines.push('## Action Items')
+    for (const a of actionsResult.rows) {
+      const check = a.status === 'done' ? '[x]' : '[ ]'
+      lines.push(`- ${check} ${a.content}${a.assignee ? ` @${a.assignee}` : ''}`)
+    }
+  }
+
+  return text(lines.join('\n'))
+}

package/scaffold/pm-api/src/mcp-tools/sprint.ts

@@ -0,0 +1,204 @@
+import { query, execute } from '../db/adapter.js'
+import { text, err, today, resolveSprint, notify, checkRateLimit, emitAgentEvent, validateAssignee, resolveMemberId, progressBar, type ToolResult } from './utils.js'
+
+export async function toolListSprints(): Promise<ToolResult> {
+  const result = await query<{ id: string; title: string; active: number; start_date: string | null; end_date: string | null }>(
+    'SELECT id, title, active, start_date, end_date FROM nav_sprints ORDER BY id DESC',
+  )
+  if (result.error) return err(result.error)
+  if (result.rows.length === 0) return text('No sprints found.')
+
+  const lines = ['📅 Sprint List', '─────────────']
+  for (const s of result.rows) {
+    const marker = s.active ? ' ← active' : ''
+    const icon = s.active ? '🟢' : '⚪'
+    const dates = s.start_date && s.end_date ? ` (${s.start_date} ~ ${s.end_date})` : ''
+    lines.push(`${icon} ${s.id}: ${s.title}${dates}${marker}`)
+  }
+  return text(lines.join('\n'))
+}
+
+export async function toolActivateSprint(args: Record<string, unknown>): Promise<ToolResult> {
+  const sprintId = args.sprint_id as string
+  const r1 = await execute('UPDATE nav_sprints SET active = 0 WHERE active = 1', [])
+  if (r1.error) return err(r1.error)
+  const r2 = await execute('UPDATE nav_sprints SET active = 1 WHERE id = ?', [sprintId])
+  if (r2.error) return err(r2.error)
+  if (r2.rowsAffected === 0) return err(`Sprint '${sprintId}' not found.`)
+  return text(`✅ Sprint ${sprintId} activated.`)
+}
+
+export async function toolCloseSprint(args: Record<string, unknown>): Promise<ToolResult> {
+  const sprintId = args.sprint_id as string
+
+  // Check status
+  const sprint = await query<{ id: string; status: string }>('SELECT id, status FROM nav_sprints WHERE id = ?', [sprintId])
+  if (sprint.error) return err(sprint.error)
+  if (!sprint.rows.length) return err(`Sprint '${sprintId}' not found`)
+  if (sprint.rows[0].status !== 'active') return err(`Can only close sprints in active state (current: ${sprint.rows[0].status})`)
+
+  // Fetch stories
+  const stories = await query<{ id: number; title: string; sprint: string | null; status: string; story_points: number | null; assignee: string | null }>(
+    'SELECT id, title, sprint, status, story_points, assignee FROM pm_stories WHERE sprint = ?', [sprintId])
+  if (stories.error) return err(stories.error)
+
+  const { getIncompleteStories, getCompletedStories, generateCloseSummary } = await import('../utils/sprint-lifecycle.js')
+  const completed = getCompletedStories(stories.rows)
+  const incomplete = getIncompleteStories(stories.rows)
+  const summary = generateCloseSummary(sprintId, stories.rows)
+
+  // Incomplete → backlog
+  if (incomplete.length > 0) {
+    const ids = incomplete.map((s: { id: number }) => s.id)
+    const ph = ids.map(() => '?').join(', ')
+    await execute(`UPDATE pm_stories SET sprint = NULL, updated_at = CURRENT_TIMESTAMP WHERE id IN (${ph})`, ids)
+  }
+
+  // Close
+  await execute(`UPDATE nav_sprints SET status = 'closed', active = 0, velocity = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?`, [summary.doneSP, sprintId])
+
+  // Create retro session
+  try { await execute(`INSERT OR IGNORE INTO retro_sessions (sprint, phase) VALUES (?, 'collect')`, [sprintId]) } catch (_) {}
+
+  const lines = [
+    `🏁 ${sprintId} Sprint closed!`,
+    '─────────────',
+    `Completed: ${completed.length} (${summary.doneSP} SP)`,
+    `Incomplete: ${incomplete.length} → Returned to backlog`,
+    `Completion rate: ${summary.completionRate}%`,
+  ]
+  if (incomplete.length > 0) {
+    lines.push('', 'Stories returned to backlog:')
+    for (const s of incomplete) lines.push(`  • S${s.id}: ${s.title}`)
+  }
+  return text(lines.join('\n'))
+}
+
+export async function toolCheckinSprint(args: Record<string, unknown>): Promise<ToolResult> {
+  const sprintId = args.sprint_id as string
+  const memberIds = args.member_ids as number[]
+  if (!sprintId || !memberIds?.length) return err('sprint_id, member_ids required')
+  await execute('DELETE FROM sprint_members WHERE sprint_id = ?', [sprintId])
+  for (const mid of memberIds) {
+    await execute('INSERT OR REPLACE INTO sprint_members (sprint_id, member_id, working_days) VALUES (?, ?, 0)', [sprintId, mid])
+  }
+  await execute('UPDATE nav_sprints SET team_size = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?', [memberIds.length, sprintId])
+  return text(`✅ ${sprintId} check-in: ${memberIds.length} members registered`)
+}
+
+export async function toolAddAbsence(args: Record<string, unknown>): Promise<ToolResult> {
+  const sprintId = args.sprint_id as string
+  const memberId = args.member_id as number
+  const dates = args.dates as string[]
+  const reason = (args.reason as string) ?? null
+  if (!sprintId || !memberId || !dates?.length) return err('sprint_id, member_id, dates required')
+  for (const d of dates) {
+    await execute('INSERT OR IGNORE INTO member_absences (sprint_id, member_id, absence_date, reason) VALUES (?, ?, ?, ?)', [sprintId, memberId, d, reason])
+  }
+  return text(`✅ ${sprintId} absence registered: ${dates.length} day(s)`)
+}
+
+export async function toolGetVelocity(): Promise<ToolResult> {
+  const result = await query<{ sprint: string; done_sp: number; total_sp: number; story_count: number }>(
+    `SELECT s.sprint,
+            SUM(CASE WHEN s.status = 'done' THEN COALESCE(s.story_points, 0) ELSE 0 END) as done_sp,
+            SUM(COALESCE(s.story_points, 0)) as total_sp,
+            COUNT(*) as story_count
+     FROM pm_stories s
+     JOIN nav_sprints ns ON s.sprint = ns.id
+     WHERE ns.status = 'closed' AND s.sprint IS NOT NULL
+     GROUP BY s.sprint
+     ORDER BY ns.sort_order`)
+  if (result.error) return err(result.error)
+
+  const sprints = result.rows
+  const doneSPs = sprints.map(s => s.done_sp)
+  const avgVelocity = doneSPs.length ? Math.round(doneSPs.reduce((a, b) => a + b, 0) / doneSPs.length) : 0
+  const lastThree = doneSPs.slice(-3)
+  const recentAvg = lastThree.length ? Math.round(lastThree.reduce((a, b) => a + b, 0) / lastThree.length) : 0
+
+  const lines = [
+    '📊 Velocity Report',
+    '─────────────',
+    `Overall average: ${avgVelocity} SP (${sprints.length} sprints)`,
+    `Recent 3 average: ${recentAvg} SP`,
+    '',
+    'Sprint results:',
+  ]
+  for (const s of sprints) {
+    lines.push(`  ${s.sprint}: ${s.done_sp}/${s.total_sp} SP (${s.story_count} stories)`)
+  }
+  if (!sprints.length) lines.push('  (No completed sprints)')
+  return text(lines.join('\n'))
+}
+
+export async function toolKickoffSprint(args: Record<string, unknown>): Promise<ToolResult> {
+  const sprintId = args.sprint_id as string
+  const storyIds = args.story_ids as number[]
+  const teamMembers = (args.team_members as string[]) ?? []
+  const velocity = (args.velocity as number) ?? null
+
+  if (!storyIds?.length) return err('story_ids required')
+
+  // Check sprint status
+  const sprint = await query<{ id: string; status: string }>('SELECT id, status FROM nav_sprints WHERE id = ?', [sprintId])
+  if (sprint.error) return err(sprint.error)
+  if (!sprint.rows.length) return err(`Sprint '${sprintId}' not found`)
+  if (sprint.rows[0].status !== 'planning') return err(`Kickoff is only available in planning state (current: ${sprint.rows[0].status})`)
+
+  // Total SP
+  const placeholders = storyIds.map(() => '?').join(', ')
+  const stories = await query<{ id: number; title: string; story_points: number | null }>(
+    `SELECT id, title, story_points FROM pm_stories WHERE id IN (${placeholders})`, storyIds)
+  if (stories.error) return err(stories.error)
+  const totalSP = stories.rows.reduce((sum, s) => sum + (s.story_points ?? 0), 0)
+
+  // Assign stories
+  const assignResult = await execute(
+    `UPDATE pm_stories SET sprint = ?, updated_at = CURRENT_TIMESTAMP WHERE id IN (${placeholders})`,
+    [sprintId, ...storyIds])
+  if (assignResult.error) return err(assignResult.error)
+
+  // Activate sprint
+  await execute('UPDATE nav_sprints SET active = 0, status = \'closed\', updated_at = CURRENT_TIMESTAMP WHERE active = 1 AND id != ?', [sprintId])
+  await execute('UPDATE nav_sprints SET status = \'active\', active = 1, velocity = ?, team_size = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
+    [velocity, teamMembers.length || null, sprintId])
+
+  const lines = [
+    `🚀 ${sprintId} Kickoff complete!`,
+    `─────────────`,
+    `Stories: ${storyIds.length} assigned`,
+    `SP total: ${totalSP}${velocity ? ` / velocity: ${velocity}` : ''}`,
+  ]
+  if (velocity && totalSP > velocity) lines.push(`⚠️ SP exceeds velocity target!`)
+  if (teamMembers.length) lines.push(`Members: ${teamMembers.join(', ')}`)
+  return text(lines.join('\n'))
+}
+
+export async function toolSprintSummary(args: Record<string, unknown>): Promise<ToolResult> {
+  const sprint = await resolveSprint(args.sprint as string | undefined)
+  if (!sprint) return err('Please specify a sprint.')
+
+  const [epicResult, assigneeResult, blockerResult] = await Promise.all([
+    query<{ epic_title: string; total: number; done: number }>(`SELECT COALESCE(e.title, '(No epic)') as epic_title, COUNT(t.id) as total, SUM(CASE WHEN t.status = 'done' THEN 1 ELSE 0 END) as done FROM pm_tasks t JOIN pm_stories s ON t.story_id = s.id LEFT JOIN pm_epics e ON s.epic_id = e.id WHERE s.sprint = ? GROUP BY e.title ORDER BY e.title`, [sprint]),
+    query<{ assignee: string; total: number; done: number; in_progress: number; todo: number }>(`SELECT COALESCE(t.assignee, 'Unassigned') as assignee, COUNT(t.id) as total, SUM(CASE WHEN t.status = 'done' THEN 1 ELSE 0 END) as done, SUM(CASE WHEN t.status = 'in-progress' THEN 1 ELSE 0 END) as in_progress, SUM(CASE WHEN t.status = 'todo' THEN 1 ELSE 0 END) as todo FROM pm_tasks t JOIN pm_stories s ON t.story_id = s.id WHERE s.sprint = ? GROUP BY t.assignee ORDER BY total DESC`, [sprint]),
+    query<{ user_name: string; blockers: string; entry_date: string }>(`SELECT user_name, blockers, entry_date FROM pm_standup_entries WHERE sprint = ? AND blockers IS NOT NULL AND blockers != '' ORDER BY entry_date DESC LIMIT 10`, [sprint]),
+  ])
+
+  const lines = [`📊 ${sprint.toUpperCase()} Sprint Summary`, '─────────────']
+  if (!epicResult.error) for (const e of epicResult.rows) {
+    const pct = e.total > 0 ? Math.round((e.done / e.total) * 100) : 0
+    lines.push(`🏷 ${e.epic_title}: ${progressBar(e.done, e.total)} ${e.done}/${e.total} (${pct}%)`)
+  }
+  if (!assigneeResult.error && assigneeResult.rows.length > 0) {
+    lines.push('')
+    for (const a of assigneeResult.rows) lines.push(`👤 ${a.assignee}: ${a.total} tasks (done ${a.done}, in-progress ${a.in_progress}, todo ${a.todo})`)
+  }
+  if (!blockerResult.error && blockerResult.rows.length > 0) {
+    lines.push('', `🚧 Blockers: ${blockerResult.rows.length}`)
+    for (const b of blockerResult.rows) lines.push(`  - [${b.entry_date}] ${b.user_name}: ${b.blockers}`)
+  } else {
+    lines.push('', '🚧 Blockers: 0')
+  }
+  return text(lines.join('\n'))
+}