popilot 0.6.0 → 0.7.0

package/scaffold/pm-api/src/nudge.ts

@@ -0,0 +1,283 @@
+/**
+ * Proactive Nudge — Cron-triggered check & webhook notification module
+ */
+
+// ── Types ──
+interface NudgeRule {
+  id: string
+  label: string
+  check: (env: Env) => Promise<NudgeMessage[]>
+}
+
+interface NudgeMessage {
+  ruleId: string
+  title: string
+  body: string
+  mentions?: string[] // user names
+}
+
+interface Env {
+  DB_URL: string
+  DB_AUTH_TOKEN: string
+  NUDGE_WEBHOOK_URL?: string
+}
+
+// ── DB helper (standalone fetch for cron context) ──
+async function query(env: Env, sql: string, args: unknown[] = []): Promise<Record<string, unknown>[]> {
+  const res = await fetch(`${env.DB_URL}/v2/pipeline`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${env.DB_AUTH_TOKEN}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      requests: [
+        { type: 'execute', stmt: { sql, args: args.map(a => ({ type: typeof a === 'number' ? 'integer' : 'text', value: String(a) })) } },
+        { type: 'close' },
+      ],
+    }),
+  })
+  const data = (await res.json()) as { results?: Array<{ response?: { result?: { cols?: Array<{ name: string }>; rows?: unknown[][] } } }> }
+  const result = data.results?.[0]?.response?.result
+  if (!result?.cols || !result?.rows) return []
+  return result.rows.map((row: unknown[]) => {
+    const obj: Record<string, unknown> = {}
+    result.cols!.forEach((col: { name: string }, i: number) => {
+      obj[col.name] = (row[i] as { value?: unknown })?.value ?? row[i]
+    })
+    return obj
+  })
+}
+
+// ── Rules ──
+
+// Rule 1: review_required memo unanswered for 24h
+const reviewOverdue: NudgeRule = {
+  id: 'review_overdue',
+  label: 'Review request unanswered for 24h',
+  check: async (env) => {
+    const rows = await query(env,
+      `SELECT id, title, content, assigned_to, created_by, created_at
+       FROM memos_v2
+       WHERE review_required = 1
+         AND status = 'open'
+         AND created_at <= datetime('now', '-24 hours')
+       LIMIT 10`)
+    return rows.map(r => ({
+      ruleId: 'review_overdue',
+      title: `Pending review: ${r.title || (r.content as string).slice(0, 30)}`,
+      body: `${r.created_by} → ${r.assigned_to} | waiting since ${r.created_at}`,
+      mentions: r.assigned_to ? [r.assigned_to as string] : [],
+    }))
+  },
+}
+
+// Rule 2: Sprint deadline within 3 days, less than 50% complete
+const sprintDeadline: NudgeRule = {
+  id: 'sprint_deadline',
+  label: 'Sprint deadline approaching',
+  check: async (env) => {
+    // Check active sprint
+    const sprints = await query(env,
+      `SELECT id, end_date FROM nav_sprints WHERE active = 1 LIMIT 1`)
+    if (!sprints.length) return []
+    const sprint = sprints[0]
+    const endDate = new Date(sprint.end_date as string)
+    const now = new Date()
+    const daysLeft = Math.ceil((endDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24))
+    if (daysLeft > 3) return []
+
+    // Check progress
+    const stories = await query(env,
+      `SELECT status FROM pm_stories WHERE sprint = ? AND status != 'cancelled'`,
+      [sprint.id as string])
+    if (!stories.length) return []
+    const done = stories.filter(s => s.status === 'done').length
+    const total = stories.length
+    const pct = Math.round((done / total) * 100)
+    if (pct >= 50) return [] // 50%+ is OK
+
+    return [{
+      ruleId: 'sprint_deadline',
+      title: `${sprint.id} due in ${daysLeft} days — progress ${pct}%`,
+      body: `${done}/${total} stories completed. Due: ${sprint.end_date}`,
+    }]
+  },
+}
+
+// Rule 3: Standup not submitted today
+const standupMissing: NudgeRule = {
+  id: 'standup_missing',
+  label: 'Standup not submitted',
+  check: async (env) => {
+    const now = new Date()
+    const today = now.toISOString().split('T')[0]
+
+    // Active sprint
+    const sprints = await query(env,
+      `SELECT id FROM nav_sprints WHERE active = 1 LIMIT 1`)
+    if (!sprints.length) return []
+
+    // Who submitted today
+    const written = await query(env,
+      `SELECT DISTINCT user_name FROM pm_standup_entries WHERE entry_date = ?`, [today])
+    const writtenSet = new Set(written.map(w => w.user_name as string))
+
+    // All team members
+    const members = await query(env,
+      `SELECT DISTINCT user_name FROM auth_tokens WHERE is_active = 1`)
+    const missing = members
+      .map(m => m.user_name as string)
+      .filter(name => !writtenSet.has(name))
+
+    if (!missing.length) return []
+
+    // Only trigger in afternoon (give people time to write)
+    const hour = now.getUTCHours()
+    if (hour < 8) return [] // Before 08:00 UTC
+
+    return [{
+      ruleId: 'standup_missing',
+      title: `Standup not submitted: ${missing.length} members`,
+      body: `Missing: ${missing.join(', ')}`,
+      mentions: missing,
+    }]
+  },
+}
+
+// Rule 4: Task stagnant 3+ days in-progress
+const taskStagnant: NudgeRule = {
+  id: 'task_stagnant',
+  label: 'Task stagnant 3+ days',
+  check: async (env) => {
+    const rows = await query(env,
+      `SELECT t.id, t.title, t.assignee, t.updated_at, s.title as story_title
+       FROM pm_tasks t
+       JOIN pm_stories s ON t.story_id = s.id
+       JOIN nav_sprints sp ON s.sprint = sp.id AND sp.active = 1
+       WHERE t.status = 'in-progress'
+         AND t.updated_at <= datetime('now', '-3 days')
+       LIMIT 10`)
+    return rows.map(r => ({
+      ruleId: 'task_stagnant',
+      title: `Task stagnant 3+ days: ${(r.title as string).slice(0, 40)}`,
+      body: `Assignee: ${r.assignee || 'Unassigned'} | Story: ${r.story_title} | Last update: ${r.updated_at}`,
+      mentions: r.assignee ? [r.assignee as string] : [],
+    }))
+  },
+}
+
+// Rule 5: Unresolved blocker
+const blockerOpen: NudgeRule = {
+  id: 'blocker_open',
+  label: 'Unresolved blocker',
+  check: async (env) => {
+    const rows = await query(env,
+      `SELECT id, title, content, created_by, assigned_to, created_at
+       FROM memos_v2
+       WHERE memo_type = 'blocker'
+         AND status = 'open'
+       LIMIT 10`)
+    return rows.map(r => ({
+      ruleId: 'blocker_open',
+      title: `Unresolved blocker: ${r.title || (r.content as string).slice(0, 30)}`,
+      body: `Author: ${r.created_by} | Assignee: ${r.assigned_to || 'Unassigned'} | open since ${r.created_at}`,
+      mentions: r.assigned_to ? [r.assigned_to as string] : [],
+    }))
+  },
+}
+
+// Rule 6: Sprint daily progress report
+const sprintDailyReport: NudgeRule = {
+  id: 'sprint_daily_report',
+  label: 'Sprint daily progress',
+  check: async (env) => {
+    const sprints = await query(env,
+      `SELECT id, end_date, theme FROM nav_sprints WHERE active = 1 LIMIT 1`)
+    if (!sprints.length) return []
+    const sprint = sprints[0]
+    const endDate = new Date(sprint.end_date as string)
+    const now = new Date()
+    const daysLeft = Math.ceil((endDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24))
+
+    const stories = await query(env,
+      `SELECT status FROM pm_stories WHERE sprint = ? AND status != 'cancelled'`,
+      [sprint.id as string])
+    if (!stories.length) return []
+
+    const done = stories.filter(s => s.status === 'done').length
+    const inProgress = stories.filter(s => s.status === 'in-progress').length
+    const total = stories.length
+    const pct = Math.round((done / total) * 100)
+
+    // Only trigger in afternoon
+    const hour = now.getUTCHours()
+    if (hour < 8) return [] // Before 08:00 UTC
+
+    return [{
+      ruleId: 'sprint_daily_report',
+      title: `${sprint.id} Daily Report — ${pct}% completed`,
+      body: `completed ${done} / in-progress ${inProgress} / total ${total} | D-${daysLeft} (Due: ${sprint.end_date})`,
+    }]
+  },
+}
+
+const RULES: NudgeRule[] = [reviewOverdue, sprintDeadline, standupMissing, taskStagnant, blockerOpen, sprintDailyReport]
+
+// ── Webhook sender ──
+async function sendWebhook(env: Env, messages: NudgeMessage[]): Promise<void> {
+  const url = env.NUDGE_WEBHOOK_URL
+  if (!url || !messages.length) return
+
+  // Discord/Slack compatible embed format
+  const embeds = messages.map(m => ({
+    title: m.title,
+    description: m.body,
+    color: m.ruleId === 'review_overdue' ? 0xf59e0b
+         : m.ruleId === 'sprint_deadline' ? 0xef4444
+         : m.ruleId === 'task_stagnant' ? 0xf97316
+         : m.ruleId === 'blocker_open' ? 0xdc2626
+         : m.ruleId === 'sprint_daily_report' ? 0x8b5cf6
+         : 0x3b82f6,
+    footer: { text: `nudge:${m.ruleId}` },
+  }))
+
+  // Discord webhook
+  await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ embeds }),
+  })
+}
+
+// ── Nudge log ──
+async function logNudges(env: Env, messages: NudgeMessage[]): Promise<void> {
+  for (const m of messages) {
+    await query(env,
+      `INSERT INTO nudge_log (rule_id, title, body, created_at) VALUES (?, ?, ?, datetime('now'))`,
+      [m.ruleId, m.title, m.body])
+  }
+}
+
+// ── Main entry ──
+export async function handleScheduled(env: Env): Promise<void> {
+  const allMessages: NudgeMessage[] = []
+
+  for (const rule of RULES) {
+    try {
+      const msgs = await rule.check(env)
+      allMessages.push(...msgs)
+    } catch (e) {
+      console.error(`Nudge rule ${rule.id} failed:`, e)
+    }
+  }
+
+  if (allMessages.length > 0) {
+    await sendWebhook(env, allMessages)
+    await logNudges(env, allMessages)
+  }
+
+  if (allMessages.length > 0) {
+    console.log(`Nudge: ${allMessages.length} messages sent (${allMessages.map(m => m.ruleId).join(', ')})`)
+  }
+}

package/scaffold/pm-api/src/routes/auth.ts

@@ -0,0 +1,32 @@
+import { Hono } from 'hono'
+import type { AppEnv } from '../types.js'
+import { query } from '../db/adapter.js'
+
+const app = new Hono<AppEnv>()
+
+// POST /api/auth/verify — public (no auth middleware)
+app.post('/verify', async (c) => {
+  const body = await c.req.json<{ token?: string }>().catch(() => ({} as { token?: string }))
+  const token = body.token
+  if (!token) {
+    return c.json({ error: 'Missing token' }, 400)
+  }
+
+  const result = await query<{ user_name: string }>(
+    `SELECT user_name FROM auth_tokens
+     WHERE token = ? AND is_active = 1
+     AND (expires_at IS NULL OR expires_at > datetime('now'))`,
+    [token],
+  )
+
+  if (result.error) {
+    return c.json({ error: 'Verification failed' }, 500)
+  }
+  if (result.rows.length === 0) {
+    return c.json({ error: 'Invalid or expired token' }, 401)
+  }
+
+  return c.json({ userName: result.rows[0].user_name })
+})
+
+export default app

package/scaffold/pm-api/src/routes/v2-activity.ts

@@ -0,0 +1,27 @@
+import { Hono } from 'hono'
+import type { AppEnv } from '../types.js'
+import { queryOrThrow } from '../utils/db.js'
+
+const app = new Hono<AppEnv>()
+
+// GET / — activity feed
+app.get('/', async (c) => {
+  const limit = Number(c.req.query('limit') ?? '50')
+  const date = c.req.query('date')
+
+  let sql = 'SELECT * FROM activity_log'
+  const args: (string | number)[] = []
+
+  if (date) {
+    sql += ' WHERE created_at >= ? AND created_at < ?'
+    args.push(date, date + 'T23:59:59')
+  }
+
+  sql += ' ORDER BY created_at DESC LIMIT ?'
+  args.push(limit)
+
+  const { rows } = await queryOrThrow(sql, args)
+  return c.json({ activities: rows })
+})
+
+export default app

package/scaffold/pm-api/src/routes/v2-admin.ts

@@ -0,0 +1,165 @@
+import { Hono } from 'hono'
+import type { AppEnv } from '../types.js'
+import { queryOrThrow, executeOrThrow } from '../utils/db.js'
+
+const app = new Hono<AppEnv>()
+
+// ── Members (from members table) ──
+
+// GET /members — list from members table (primary), with auth_tokens info joined
+app.get('/members', async (c) => {
+  const { rows } = await queryOrThrow(
+    `SELECT m.id, m.display_name, m.email, m.role, m.is_active, m.webhook_url, m.wallet_address, m.created_at, m.updated_at
+     FROM members m ORDER BY m.is_active DESC, m.display_name`,
+  )
+  return c.json({ members: rows })
+})
+
+// PATCH /members/:id — update display_name, email, role
+app.patch('/members/:id', async (c) => {
+  const id = Number(c.req.param('id'))
+  const body = await c.req.json<{ display_name?: string; email?: string; role?: string; webhook_url?: string | null; wallet_address?: string | null }>()
+  const sets: string[] = []
+  const args: (string | number)[] = []
+
+  if (body.display_name !== undefined) { sets.push('display_name = ?'); args.push(body.display_name) }
+  if (body.email !== undefined) { sets.push('email = ?'); args.push(body.email) }
+  if (body.role !== undefined) { sets.push('role = ?'); args.push(body.role) }
+  if (body.webhook_url !== undefined) { sets.push('webhook_url = ?'); args.push(body.webhook_url ?? '') }
+  if (body.wallet_address !== undefined) { sets.push('wallet_address = ?'); args.push(body.wallet_address ?? '') }
+  if ((body as any).is_active !== undefined) { sets.push('is_active = ?'); args.push((body as any).is_active ? 1 : 0) }
+  if (sets.length === 0) return c.json({ ok: true })
+
+  sets.push('updated_at = CURRENT_TIMESTAMP')
+  args.push(id)
+  const { rowsAffected } = await executeOrThrow(`UPDATE members SET ${sets.join(', ')} WHERE id = ?`, args)
+  return c.json({ ok: true })
+})
+
+// ── Auth Tokens (keep existing endpoints working) ──
+
+// POST /members (create auth token — legacy)
+app.post('/members', async (c) => {
+  const body = await c.req.json<{
+    token: string; userName: string; userEmail?: string; ttlDays?: number
+  }>()
+
+  let sql: string
+  let args: (string | null)[]
+
+  if (body.ttlDays) {
+    sql = `INSERT INTO auth_tokens (token, user_name, user_email, expires_at) VALUES (?, ?, ?, datetime('now', '+' || ? || ' days'))`
+    args = [body.token, body.userName, body.userEmail ?? null, String(body.ttlDays)]
+  } else {
+    sql = 'INSERT INTO auth_tokens (token, user_name, user_email) VALUES (?, ?, ?)'
+    args = [body.token, body.userName, body.userEmail ?? null]
+  }
+
+  const { rowsAffected } = await executeOrThrow(sql, args)
+
+  // Also insert into members table (skip if already exists)
+  try {
+    await executeOrThrow(
+      "INSERT INTO members (display_name, email, role, is_active) VALUES (?, ?, 'member', 1)",
+      [body.userName, body.userEmail ?? null],
+    )
+  } catch {
+    // Ignore if already exists
+  }
+
+  return c.json({ ok: true }, 201)
+})
+
+// PATCH /members/:token/revoke
+app.patch('/members/:token/revoke', async (c) => {
+  const token = c.req.param('token')
+  const { rowsAffected } = await executeOrThrow(
+    'UPDATE auth_tokens SET is_active = 0 WHERE token = ?',
+    [token],
+  )
+  return c.json({ ok: true })
+})
+
+// PATCH /members/:token/activate
+app.patch('/members/:token/activate', async (c) => {
+  const token = c.req.param('token')
+  const { rowsAffected } = await executeOrThrow(
+    'UPDATE auth_tokens SET is_active = 1 WHERE token = ?',
+    [token],
+  )
+  return c.json({ ok: true })
+})
+
+// POST /members/:token/regenerate
+app.post('/members/:token/regenerate', async (c) => {
+  const token = c.req.param('token')
+  const body = await c.req.json<{ newToken: string }>()
+  const { rowsAffected } = await executeOrThrow(
+    'UPDATE auth_tokens SET token = ?, created_at = CURRENT_TIMESTAMP WHERE token = ?',
+    [body.newToken, token],
+  )
+  return c.json({ ok: true })
+})
+
+// DELETE /members/:id — deactivate members + auth_tokens (by numeric ID)
+app.delete('/members/:id', async (c) => {
+  const id = Number(c.req.param('id'))
+  const { rows } = await queryOrThrow<{ display_name: string }>('SELECT display_name FROM members WHERE id = ?', [id])
+  if (!rows.length) return c.json({ error: 'Member not found' }, 404)
+  await executeOrThrow('UPDATE members SET is_active = 0 WHERE id = ?', [id])
+  await executeOrThrow('UPDATE auth_tokens SET is_active = 0 WHERE user_name = ?', [rows[0].display_name])
+  return c.json({ ok: true })
+})
+
+// ── Spec Rules management ──
+
+// DELETE /spec-rules/:pageId/:ruleId
+app.delete('/spec-rules/:pageId/:ruleId', async (c) => {
+  const pageId = c.req.param('pageId')
+  const ruleId = c.req.param('ruleId')
+  const { rowsAffected } = await executeOrThrow(
+    'DELETE FROM spec_rules WHERE page_id = ? AND id = ?',
+    [pageId, ruleId],
+  )
+  return c.json({ ok: true })
+})
+
+// PATCH /spec-areas/:pageId/:areaId — update rule_count etc
+app.patch('/spec-areas/:pageId/:areaId', async (c) => {
+  const pageId = c.req.param('pageId')
+  const areaId = c.req.param('areaId')
+  const body = await c.req.json<{ ruleCount?: number; label?: string; shortLabel?: string }>()
+  const sets: string[] = []
+  const args: (string | number | null)[] = []
+  if (body.ruleCount !== undefined) { sets.push('rule_count = ?'); args.push(body.ruleCount) }
+  if (body.label !== undefined) { sets.push('label = ?'); args.push(body.label) }
+  if (body.shortLabel !== undefined) { sets.push('short_label = ?'); args.push(body.shortLabel) }
+  if (sets.length === 0) return c.json({ ok: true })
+  args.push(pageId, areaId)
+  const { rowsAffected } = await executeOrThrow(`UPDATE spec_areas SET ${sets.join(', ')} WHERE page_id = ? AND area_id = ?`, args)
+  return c.json({ ok: true })
+})
+
+// ── Settings (key-value) ──
+app.get('/settings', async (c) => {
+  const { rows } = await queryOrThrow('SELECT key, value FROM settings')
+  const obj: Record<string, string> = {}
+  for (const r of rows as Array<{ key: string; value: string }>) obj[r.key] = r.value
+  return c.json({ settings: obj })
+})
+
+app.put('/settings/:key', async (c) => {
+  const key = c.req.param('key')
+  const body = await c.req.json<{ value?: string | null }>()
+  if (!body.value) {
+    await executeOrThrow('DELETE FROM settings WHERE key = ?', [key])
+  } else {
+    await executeOrThrow(
+      "INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
+      [key, body.value],
+    )
+  }
+  return c.json({ ok: true })
+})
+
+export default app

package/scaffold/pm-api/src/routes/v2-dashboard.ts

@@ -0,0 +1,189 @@
+import { Hono } from 'hono'
+import type { AppEnv } from '../types.js'
+import { query, execute } from '../db/adapter.js'
+import { queryOrThrow, executeOrThrow } from '../utils/db.js'
+
+const app = new Hono<AppEnv>()
+
+// GET /unread-memos — unread memos (assigned to me, unanswered)
+// ?review_required=1 to filter approval-pending only
+app.get('/unread-memos', async (c) => {
+  const user = c.get('userName')
+  const reviewFilter = c.req.query('review_required')
+  const memoTypeFilter = c.req.query('memo_type')
+
+  let sql = `SELECT m.id, m.content, m.memo_type, m.created_by, m.created_at, m.review_required, m.page_id, m.title, m.supersedes_id,
+            (SELECT COUNT(*) FROM memo_replies r WHERE r.memo_id = m.id) as reply_count
+     FROM memos_v2 m
+     WHERE m.assigned_to LIKE '%' || ? || '%'
+       AND m.status = 'open'
+       AND (SELECT COUNT(*) FROM memo_replies r WHERE r.memo_id = m.id) = 0`
+
+  const args: (string | number)[] = [user]
+
+  if (reviewFilter === '1') {
+    sql += ` AND m.review_required = 1`
+  }
+  if (memoTypeFilter) {
+    sql += ` AND m.memo_type = ?`
+    args.push(memoTypeFilter)
+  }
+
+  sql += ` ORDER BY m.review_required DESC, m.created_at DESC LIMIT 20`
+
+  const { rows } = await queryOrThrow(sql, args)
+  return c.json({ unreadMemos: rows })
+})
+
+// GET /sprint-progress — sprint progress (?user= personal filter)
+app.get('/sprint-progress', async (c) => {
+  const sprint = c.req.query('sprint')
+  const userFilter = c.req.query('user')
+  if (!sprint) return c.json({ error: 'sprint required' }, 400)
+
+  let sql = `SELECT status, COUNT(*) as cnt FROM pm_stories WHERE sprint = ?`
+  const args: (string)[] = [sprint]
+
+  if (userFilter) {
+    sql += ` AND assignee LIKE '%' || ? || '%'`
+    args.push(userFilter)
+  }
+
+  sql += ` GROUP BY status`
+
+  const { rows } = await queryOrThrow(sql, args)
+
+  const statusMap: Record<string, number> = {}
+  let total = 0
+  for (const row of rows as any[]) {
+    statusMap[row.status] = row.cnt
+    total += row.cnt
+  }
+  const done = statusMap['done'] || 0
+
+  return c.json({
+    sprint,
+    total,
+    done,
+    progressPercent: total > 0 ? Math.round(done / total * 100) : 0,
+    byStatus: statusMap,
+  })
+})
+
+// GET /standup-status — today's standup submission status
+app.get('/standup-status', async (c) => {
+  const sprint = c.req.query('sprint')
+  const date = c.req.query('date')
+  if (!sprint || !date) return c.json({ error: 'sprint and date required' }, 400)
+
+  const { rows } = await queryOrThrow(
+    `SELECT user_name, done_text, plan_text FROM pm_standup_entries WHERE sprint = ? AND entry_date = ?`,
+    [sprint, date],
+  )
+
+  const written = (rows as any[]).map(r => r.user_name)
+  return c.json({ date, written, count: written.length })
+})
+
+// GET /my-requests — requests I created
+app.get('/my-requests', async (c) => {
+  const user = c.get('userName')
+  const { rows } = await queryOrThrow(
+    `SELECT id, title, content, memo_type, assigned_to, status, created_at, supersedes_id
+     FROM memos_v2
+     WHERE created_by = ? AND memo_type IN ('decision', 'feature_request', 'policy_request')
+     ORDER BY created_at DESC LIMIT 20`,
+    [user],
+  )
+  return c.json({ myRequests: rows })
+})
+
+// GET /active-decisions — active decisions
+app.get('/active-decisions', async (c) => {
+  const { rows } = await queryOrThrow(
+    `SELECT id, title, content, created_by, assigned_to, created_at, supersedes_id
+     FROM memos_v2
+     WHERE memo_type = 'decision' AND status = 'open'
+     ORDER BY created_at DESC LIMIT 20`,
+  )
+  return c.json({ decisions: rows })
+})
+
+// GET /supersede-chain/:id — trace supersede chain
+app.get('/supersede-chain/:id', async (c) => {
+  const id = Number(c.req.param('id'))
+  const chain: any[] = []
+  let currentId: number | null = id
+
+  for (let i = 0; i < 10 && currentId; i++) {
+    const chainResult: { rows: Record<string, unknown>[] } = await queryOrThrow(
+      'SELECT id, title, content, memo_type, status, created_by, created_at, supersedes_id FROM memos_v2 WHERE id = ?',
+      [currentId],
+    )
+    if (chainResult.rows.length === 0) break
+    chain.push(chainResult.rows[0])
+    currentId = (chainResult.rows[0] as any).supersedes_id
+  }
+
+  return c.json({ chain: chain.reverse() })
+})
+
+// GET /nudge-log — recent Nudge history
+app.get('/nudge-log', async (c) => {
+  const limit = parseInt(c.req.query('limit') ?? '20')
+  const nudgeRows = await query(
+    `SELECT id, rule_id, title, body, created_at FROM nudge_log ORDER BY created_at DESC LIMIT ?`,
+    [limit],
+  )
+  return c.json({ nudges: (nudgeRows as { rows?: unknown[] }).rows ?? [] })
+})
+
+// DELETE /nudge-log/:id — delete Nudge log (admin only)
+app.delete('/nudge-log/:id', async (c) => {
+  const userName = c.get('userName')
+  const { isAdmin } = await import('../utils/admin.js')
+  if (!await isAdmin(userName)) return c.json({ error: 'Admin privileges required' }, 403)
+  const id = Number(c.req.param('id'))
+  const { rowsAffected } = await executeOrThrow('DELETE FROM nudge_log WHERE id = ?', [id])
+  return c.json({ ok: true })
+})
+
+// GET /my-summary — personal dashboard summary
+app.get('/my-summary', async (c) => {
+  const user = c.req.query('user')
+  if (!user) return c.json({ error: 'user query param required' }, 400)
+
+  const [storiesRes, reviewsRes, mentionsRes, memosRes] = await Promise.all([
+    queryOrThrow(
+      "SELECT id, title, story_points, sprint, status, start_date FROM pm_stories WHERE assignee LIKE ? AND status = 'in-progress'",
+      [`%${user}%`],
+    ),
+    queryOrThrow(
+      "SELECT id, title, story_points, status, assignee FROM pm_stories WHERE status IN ('review', 'qa')",
+    ),
+    queryOrThrow<{ count: number }>(
+      "SELECT COUNT(*) as count FROM notifications WHERE user_name = ? AND is_read = 0 AND type = 'mention'",
+      [user],
+    ),
+    queryOrThrow<{ count: number }>(
+      "SELECT COUNT(*) as count FROM memos_v2 WHERE assigned_to LIKE ? AND status = 'open'",
+      [`%${user}%`],
+    ),
+  ])
+
+  // days_in_progress calculation
+  const now = new Date()
+  const myStories = storiesRes.rows.map((s: any) => ({
+    ...s,
+    daysInProgress: s.start_date ? Math.floor((now.getTime() - new Date(s.start_date + 'Z').getTime()) / 86400000) : null,
+  }))
+
+  return c.json({
+    myStories,
+    myReviews: reviewsRes.rows,
+    unreadMentions: (mentionsRes.rows[0] as any)?.count ?? 0,
+    unansweredMemos: (memosRes.rows[0] as any)?.count ?? 0,
+  })
+})
+
+export default app