popilot 0.6.0 → 0.7.0

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'))
+}

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

@@ -0,0 +1,136 @@
+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 toolGetStandup(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 d = (args.date as string) || today()
+
+  const result = await query<{ id: number; done_text: string | null; plan_text: string | null; plan_story_ids: string | null; blockers: string | null; created_at: string; updated_at: string }>('SELECT * FROM pm_standup_entries WHERE sprint = ? AND user_name = ? AND entry_date = ?', [sprint, user, d])
+  if (result.error) return err(result.error)
+  if (result.rows.length === 0) return text(`📝 No standup found for ${d}.`)
+
+  const e = result.rows[0]
+  const storyIds: number[] = e.plan_story_ids ? JSON.parse(e.plan_story_ids) : []
+  let storyTitles = ''
+  if (storyIds.length > 0) {
+    const ph = storyIds.map(() => '?').join(',')
+    const sr = await query<{ id: number; title: string }>(`SELECT id, title FROM pm_stories WHERE id IN (${ph})`, storyIds)
+    if (!sr.error) storyTitles = sr.rows.map(s => `  - [S${s.id}] ${s.title}`).join('\n')
+  }
+
+  const lines = [`📝 ${user}'s Standup (${d})`, '─────────────', `✅ Done: ${e.done_text ?? '(none)'}`, `📌 Plan: ${e.plan_text ?? '(none)'}`]
+  if (storyTitles) lines.push(`📖 Planned Stories:\n${storyTitles}`)
+  if (e.blockers) lines.push(`🚧 Blockers: ${e.blockers}`)
+  return text(lines.join('\n'))
+}
+
+export async function toolSaveStandup(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 d = (args.date as string) || today()
+  const storyIdsJson = (args.plan_story_ids as number[] | undefined)?.length ? JSON.stringify(args.plan_story_ids) : null
+
+  const result = await execute(
+    `INSERT INTO pm_standup_entries (sprint, user_name, entry_date, done_text, plan_text, plan_story_ids, blockers, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP) ON CONFLICT(sprint, user_name, entry_date) DO UPDATE SET done_text = excluded.done_text, plan_text = excluded.plan_text, plan_story_ids = excluded.plan_story_ids, blockers = excluded.blockers, updated_at = CURRENT_TIMESTAMP`,
+    [sprint, user, d, (args.done_text as string) ?? null, (args.plan_text as string) ?? null, storyIdsJson, (args.blockers as string) ?? null],
+  )
+  if (result.error) return err(result.error)
+  return text(`✅ ${d} standup saved`)
+}
+
+export async function toolListStandupEntries(args: Record<string, unknown>): Promise<ToolResult> {
+  const sprint = await resolveSprint(args.sprint as string | undefined)
+  const date = args.date as string | undefined
+
+  let sql: string
+  const sqlArgs: (string | number)[] = []
+
+  if (sprint && date) {
+    sql = 'SELECT * FROM pm_standup_entries WHERE sprint = ? AND entry_date = ? ORDER BY user_name'
+    sqlArgs.push(sprint, date)
+  } else if (date) {
+    sql = 'SELECT * FROM pm_standup_entries WHERE entry_date = ? ORDER BY user_name'
+    sqlArgs.push(date)
+  } else if (sprint) {
+    sql = 'SELECT * FROM pm_standup_entries WHERE sprint = ? ORDER BY entry_date DESC, user_name LIMIT 50'
+    sqlArgs.push(sprint)
+  } else {
+    return err('Please specify a sprint or date.')
+  }
+
+  const result = await query<{ user_name: string; entry_date: string; done_text: string | null; plan_text: string | null; blockers: string | null }>(sql, sqlArgs)
+  if (result.error) return err(result.error)
+  if (result.rows.length === 0) return text('No standup records found.')
+
+  const lines = ['📝 Standup Records', '─────────────']
+  for (const e of result.rows) {
+    lines.push(`\n👤 ${e.user_name} (${e.entry_date})`)
+    if (e.done_text) lines.push(`  ✅ ${e.done_text}`)
+    if (e.plan_text) lines.push(`  📌 ${e.plan_text}`)
+    if (e.blockers) lines.push(`  🚧 ${e.blockers}`)
+  }
+  return text(lines.join('\n'))
+}
+
+// ═══════════════════════════════════════════
+// Standup Feedback
+// ═══════════════════════════════════════════
+
+export async function toolReviewStandup(user: string, args: Record<string, unknown>): Promise<ToolResult> {
+  const entryId = args.standup_entry_id as number
+  const sprint = args.sprint as string
+  const targetUser = args.target_user as string
+  const feedbackText = args.feedback_text as string
+  const reviewType = (args.review_type as string) || 'comment'
+
+  if (!['comment', 'approve', 'request_changes'].includes(reviewType)) {
+    return text('❌ review_type must be one of: comment, approve, request_changes.')
+  }
+
+  // Verify the standup entry exists and validate consistency
+  const entryCheck = await query<{ id: number; user_name: string; sprint: string }>(
+    'SELECT id, user_name, sprint FROM pm_standup_entries WHERE id = ?', [entryId],
+  )
+  if (entryCheck.rows.length === 0) return text('❌ Standup entry not found.')
+  const entry = entryCheck.rows[0]
+  if (entry.sprint !== sprint) return text(`❌ Sprint mismatch: entry belongs to ${entry.sprint} but ${sprint} was requested.`)
+  if (entry.user_name !== targetUser) return text(`❌ Target user mismatch: entry author is ${entry.user_name} but ${targetUser} was requested.`)
+
+  const result = await execute(
+    'INSERT INTO pm_standup_feedback (standup_entry_id, sprint, target_user, feedback_by, feedback_text, review_type) VALUES (?, ?, ?, ?, ?, ?)',
+    [entryId, sprint, targetUser, user, feedbackText, reviewType],
+  )
+  if (result.error) return text(`❌ ${result.error}`)
+
+  const icon = reviewType === 'approve' ? '✅' : reviewType === 'request_changes' ? '🔄' : '💬'
+  return text(`${icon} Feedback registered for ${targetUser}'s standup (${reviewType})`)
+}
+
+export async function toolGetStandupFeedback(args: Record<string, unknown>): Promise<ToolResult> {
+  const entryId = args.standup_entry_id as number | undefined
+  const sprint = args.sprint as string | undefined
+  const user = args.user as string | undefined
+
+  let result
+  if (entryId) {
+    result = await query('SELECT * FROM pm_standup_feedback WHERE standup_entry_id = ? ORDER BY created_at ASC', [entryId])
+  } else if (sprint && user) {
+    result = await query('SELECT * FROM pm_standup_feedback WHERE sprint = ? AND target_user = ? ORDER BY created_at DESC LIMIT 50', [sprint, user])
+  } else {
+    return text('❌ standup_entry_id or (sprint + user) parameters required.')
+  }
+
+  if (result.error) return text(`❌ ${result.error}`)
+  if (result.rows.length === 0) return text('📝 No feedback found.')
+
+  const lines = ['📝 Standup Feedback', '─────────────']
+  for (const f of result.rows as Array<Record<string, unknown>>) {
+    const icon = f.review_type === 'approve' ? '✅' : f.review_type === 'request_changes' ? '🔄' : '💬'
+    lines.push(`${icon} [${f.review_type}] ${f.feedback_by} → ${f.target_user}`)
+    lines.push(`   ${f.feedback_text}`)
+    lines.push(`   ${f.created_at}`)
+    lines.push('')
+  }
+  return text(lines.join('\n'))
+}