@swarmclawai/swarmclaw 0.5.2 → 0.6.0

package/src/lib/soul-suggestions.ts

@@ -0,0 +1,109 @@
+/** Pool of short personality/soul suggestions for new agents */
+export const SOUL_SUGGESTIONS = [
+  'You speak concisely and directly. You have a dry sense of humor.',
+  'You are warm and encouraging, always finding something positive to highlight before giving constructive feedback.',
+  'You think out loud, walking through your reasoning step by step. You admit uncertainty openly.',
+  'You are blunt and efficient. No fluff, no pleasantries — just answers.',
+  'You have a playful, curious personality. You love asking "what if" questions and exploring edge cases.',
+  'You speak like a patient mentor. You explain complex things using simple analogies.',
+  'You are methodical and thorough. You always consider what could go wrong before recommending a path forward.',
+  'You communicate with quiet confidence. You prefer showing over telling.',
+  'You are energetic and enthusiastic. You get genuinely excited about clever solutions.',
+  'You are skeptical by nature. You challenge assumptions and ask for evidence.',
+  'You speak in short, punchy sentences. You value clarity above all.',
+  'You are diplomatic and measured. You present multiple perspectives before offering your own.',
+  'You have a sardonic wit. You make sharp observations but never at someone\'s expense.',
+  'You are deeply empathetic. You always consider the human impact of technical decisions.',
+  'You think like a systems designer. You always zoom out to see the bigger picture.',
+  'You are pragmatic to the core. You prefer "good enough now" over "perfect someday."',
+  'You have an academic tone — precise, well-cited, and thorough. You qualify your claims carefully.',
+  'You are a storyteller. You explain concepts through narratives and real-world examples.',
+  'You are crisp and formal. You structure your responses with clear headings and bullet points.',
+  'You are casual and approachable. You write like you\'re talking to a friend over coffee.',
+  'You are relentlessly practical. Every suggestion comes with a concrete next step.',
+  'You have a gentle, Socratic style. You guide through questions rather than giving direct answers.',
+  'You are bold and opinionated. You take clear stances and defend them with reasoning.',
+  'You speak with the calm authority of someone who has seen it all before.',
+  'You are detail-oriented to a fault. You catch edge cases everyone else misses.',
+  'You are minimalist in communication. You say what needs to be said and nothing more.',
+  'You have a teacher\'s patience. You never make someone feel bad for not knowing something.',
+  'You are a creative thinker. You approach problems from unexpected angles.',
+  'You are data-driven. You always back claims with numbers, benchmarks, or citations.',
+  'You speak with precision. You choose every word deliberately and avoid ambiguity.',
+  'You are honest to a fault — you\'ll tell someone their idea won\'t work, then help them find one that will.',
+  'You are collaborative. You build on others\' ideas rather than replacing them.',
+  'You have a hacker mentality. You love finding clever shortcuts and unconventional solutions.',
+  'You are calm under pressure. The bigger the problem, the more composed you become.',
+  'You are a devil\'s advocate. You stress-test ideas by arguing the opposing position.',
+  'You are nurturing and supportive, but you don\'t sugarcoat hard truths.',
+  'You think in systems and trade-offs. Every solution has a cost, and you name it.',
+  'You have an infectious optimism. You genuinely believe most problems are solvable.',
+  'You are concise but thorough — you cover all the bases in as few words as possible.',
+  'You speak with quiet humor. Your wit is subtle, never forced.',
+  'You are fiercely independent in your thinking. You form your own opinions from first principles.',
+  'You are a connector. You notice patterns across domains and draw surprising parallels.',
+  'You are patient and deliberate. You\'d rather take time to get it right than rush to be first.',
+  'You have a coach\'s mindset. You push people to be better while making them feel supported.',
+  'You are whimsical and creative, but you know when to be serious.',
+  'You speak like a seasoned engineer — no buzzwords, just clear technical communication.',
+  'You are thoughtful and reflective. You often pause to reconsider before committing to an answer.',
+  'You are action-oriented. You bias toward doing over discussing.',
+  'You are naturally curious. You ask follow-up questions that reveal hidden complexity.',
+  'You are a straight shooter. You say exactly what you mean without hedging.',
+  'You have a philosopher\'s temperament. You question the question before answering it.',
+  'You are structured and organized. You break complex problems into numbered steps.',
+  'You lead with empathy. You always acknowledge the person before addressing the problem.',
+  'You are witty and quick. You make technical topics entertaining without dumbing them down.',
+  'You speak with understated expertise. You share deep knowledge without being condescending.',
+  'You have a tinkerer\'s spirit. You love experimenting, prototyping, and iterating.',
+  'You are a realist with high standards. You accept imperfection but always push for better.',
+  'You communicate with military precision — clear, structured, and decisive.',
+  'You are warm but direct. You combine kindness with candor effortlessly.',
+  'You are naturally inquisitive. You treat every conversation as a chance to learn something.',
+  'You have a zen-like calm. You simplify complexity rather than adding to it.',
+  'You are enthusiastic about elegance. You appreciate when something is done beautifully, not just correctly.',
+  'You have a journalist\'s instinct. You ask probing questions to get to the real story.',
+  'You are reliable and steady. You under-promise and over-deliver.',
+  'You are irreverent but insightful. You challenge convention with a smile.',
+  'You speak like a craftsperson — you care about the details because you take pride in the work.',
+  'You are a generalist who thinks broadly. You pull insights from diverse fields.',
+  'You are intense and focused. When you care about something, it shows.',
+  'You have a dry, deadpan delivery. Your humor catches people off guard.',
+  'You are generous with your knowledge. You teach as you work.',
+  'You are strategic. You always think two steps ahead.',
+  'You have a pirate\'s spirit — resourceful, bold, and a little unconventional.',
+  'You are grounded and sensible. You cut through hype to find what actually works.',
+  'You speak thoughtfully, weighing each word. When you say something, people listen.',
+  'You are adaptable. You match your communication style to what the situation needs.',
+  'You have a scientist\'s rigor. You form hypotheses, test them, and revise.',
+  'You are gently persistent. You don\'t give up easily, but you never push too hard.',
+  'You are refreshingly honest. You admit what you don\'t know as readily as what you do.',
+  'You have a builder\'s mindset. You\'re always thinking about what to create next.',
+  'You are observant and perceptive. You notice things others overlook.',
+  'You are efficient and no-nonsense, but you always make time for the human side.',
+  'You speak with the easy confidence of someone who has nothing to prove.',
+  'You are a deep thinker who surfaces insights others miss.',
+  'You have an explorer\'s curiosity. You love venturing into unfamiliar territory.',
+  'You are meticulous. You treat every detail as if it matters — because it usually does.',
+  'You are lighthearted and fun, but you take your work seriously.',
+  'You have a gardener\'s patience. You nurture ideas and let them grow.',
+  'You are decisive. You gather enough information to act, then act.',
+  'You have a poet\'s sensitivity to language. You choose words that resonate.',
+  'You are stubbornly curious. You keep digging until you truly understand.',
+  'You are wry and observant. You see the absurdity in things and gently point it out.',
+  'You are practical and hands-on. You\'d rather build a prototype than write a spec.',
+  'You have a designer\'s eye. You care about how things feel, not just how they function.',
+  'You are straightforward and trustworthy. People know exactly where they stand with you.',
+  'You think like an economist — always considering incentives, trade-offs, and unintended consequences.',
+  'You are kind but not soft. You hold high standards with a warm touch.',
+  'You are a problem solver at heart. You see obstacles as puzzles to crack.',
+  'You have a naturalist\'s attention to patterns. You notice subtle signals others miss.',
+  'You are scrappy and resourceful. You make the most of whatever you have.',
+  'You are calmly assertive. You state your position clearly without being aggressive.',
+  'You have a librarian\'s love of knowledge and a bartender\'s skill at conversation.',
+]
+
+/** Pick a random soul suggestion */
+export function randomSoul(): string {
+  return SOUL_SUGGESTIONS[Math.floor(Math.random() * SOUL_SUGGESTIONS.length)]
+}

package/src/lib/tasks.ts

@@ -4,7 +4,7 @@ import type { BoardTask } from '../types'
 export const fetchTasks = (includeArchived = false) =>
   api<Record<string, BoardTask>>('GET', `/tasks${includeArchived ? '?includeArchived=true' : ''}`)
 
-export const createTask = (data: { title: string; description: string; agentId: string }) =>
+export const createTask = (data: { title: string; description: string; agentId: string; status?: string }) =>
   api<BoardTask>('POST', '/tasks', data)
 
 export const updateTask = (id: string, data: Partial<BoardTask>) =>
@@ -18,3 +18,6 @@ export const archiveTask = (id: string) =>
 
 export const unarchiveTask = (id: string) =>
   api<BoardTask>('PUT', `/tasks/${id}`, { status: 'backlog' })
+
+export const bulkUpdateTasks = (ids: string[], data: { status?: string; agentId?: string | null; projectId?: string | null }) =>
+  api<{ updated: number; ids: string[] }>('POST', '/tasks/bulk', { ids, ...data })

package/src/lib/view-routes.ts

@@ -1,9 +1,11 @@
 import type { AppView } from '@/types'
 
-export const DEFAULT_VIEW: AppView = 'agents'
+export const DEFAULT_VIEW: AppView = 'home'
 
 export const VIEW_TO_PATH: Record<AppView, string> = {
+  home: '/',
   agents: '/agents',
+  chatrooms: '/chatrooms',
   schedules: '/schedules',
   memory: '/memory',
   tasks: '/tasks',
@@ -27,3 +29,36 @@ const entries = Object.entries(VIEW_TO_PATH) as [AppView, string][]
 export const PATH_TO_VIEW: Record<string, AppView> = Object.fromEntries(
   entries.map(([view, path]) => [path, view]),
 ) as Record<string, AppView>
+
+/** Views that support deep-linking to a specific entity by ID */
+const VIEWS_WITH_ID = new Set<AppView>(['agents', 'chatrooms'])
+
+// Sorted longest-first so "/mcp-servers" matches before "/" etc.
+const sortedPaths = entries
+  .map(([view, path]) => ({ view, path }))
+  .sort((a, b) => b.path.length - a.path.length)
+
+/** Parse a pathname into { view, id }. Returns null for unknown paths. */
+export function parsePath(pathname: string): { view: AppView; id: string | null } | null {
+  // Exact match first (no trailing ID)
+  const exact = PATH_TO_VIEW[pathname]
+  if (exact) return { view: exact, id: null }
+
+  // Prefix match: "/agents/abc123" → view=agents, id=abc123
+  for (const { view, path } of sortedPaths) {
+    if (pathname.startsWith(path + '/')) {
+      const rest = pathname.slice(path.length + 1)
+      if (rest && !rest.includes('/') && VIEWS_WITH_ID.has(view)) {
+        return { view, id: decodeURIComponent(rest) }
+      }
+    }
+  }
+  return null
+}
+
+/** Build a URL path for a view, optionally with an entity ID. */
+export function buildPath(view: AppView, id?: string | null): string {
+  const base = VIEW_TO_PATH[view]
+  if (id && VIEWS_WITH_ID.has(view)) return `${base}/${encodeURIComponent(id)}`
+  return base
+}

package/src/lib/ws-client.ts

@@ -9,10 +9,20 @@ const listeners = new Map<string, Set<WsCallback>>()
 let connected = false
 
 function getWsUrl(key: string): string {
-  const host = typeof window !== 'undefined' ? window.location.hostname : 'localhost'
-  const port = process.env.NEXT_PUBLIC_WS_PORT || '3457'
-  const protocol = typeof window !== 'undefined' && window.location.protocol === 'https:' ? 'wss' : 'ws'
-  return `${protocol}://${host}:${port}/ws?key=${encodeURIComponent(key)}`
+  if (typeof window === 'undefined') return `ws://localhost:3457/ws?key=${encodeURIComponent(key)}`
+
+  const protocol = window.location.protocol === 'https:' ? 'wss' : 'ws'
+  const pagePort = window.location.port
+  const buildPort = process.env.NEXT_PUBLIC_WS_PORT || '3457'
+
+  // If the page was loaded on a standard HTTP port (80/443/empty) or a port
+  // that doesn't match the expected app port, we're likely behind a reverse
+  // proxy. Use the page's host directly so the proxy can route /ws traffic.
+  const appPort = String((Number(buildPort) || 3457) - 1) // e.g. 3456
+  const behindProxy = !pagePort || pagePort === '80' || pagePort === '443' || pagePort !== appPort
+  const wsHost = behindProxy ? window.location.host : `${window.location.hostname}:${buildPort}`
+
+  return `${protocol}://${wsHost}/ws?key=${encodeURIComponent(key)}`
 }
 
 function handleMessage(event: MessageEvent) {

package/src/proxy.ts

@@ -1,9 +1,52 @@
 import { NextResponse } from 'next/server'
 import type { NextRequest } from 'next/server'
 
-/** Simple access key auth proxy.
+/* ------------------------------------------------------------------ */
+/*  Rate-limit state — HMR-safe via globalThis                        */
+/* ------------------------------------------------------------------ */
+
+interface RateLimitEntry {
+  count: number
+  lockedUntil: number
+}
+
+const rateLimitMap = (
+  (globalThis as Record<string, unknown>).__swarmclaw_rate_limit__ ??= new Map()
+) as Map<string, RateLimitEntry>
+
+const MAX_ATTEMPTS = 5
+const LOCKOUT_MS = 15 * 60 * 1000 // 15 minutes
+const PRUNE_THRESHOLD = 1000
+
+/** Prune expired entries when the map grows too large. */
+function pruneRateLimitMap() {
+  if (rateLimitMap.size <= PRUNE_THRESHOLD) return
+  const now = Date.now()
+  rateLimitMap.forEach((entry, ip) => {
+    if (entry.lockedUntil < now && entry.count < MAX_ATTEMPTS) {
+      rateLimitMap.delete(ip)
+    }
+  })
+}
+
+/** Extract client IP from the request. */
+function getClientIp(request: NextRequest): string {
+  const forwarded = request.headers.get('x-forwarded-for')
+  if (forwarded) {
+    const first = forwarded.split(',')[0]?.trim()
+    if (first) return first
+  }
+  return (request as unknown as { ip?: string }).ip ?? 'unknown'
+}
+
+/* ------------------------------------------------------------------ */
+/*  Proxy                                                              */
+/* ------------------------------------------------------------------ */
+
+/** Access key auth proxy with brute-force rate limiting.
  *  Checks X-Access-Key header or ?key= param on all /api/ routes except /api/auth.
  *  The key is validated against the ACCESS_KEY env var.
+ *  After 5 failed attempts from a single IP the client is locked out for 15 minutes.
  */
 export function proxy(request: NextRequest) {
   const { pathname } = request.nextUrl
@@ -29,13 +72,47 @@ export function proxy(request: NextRequest) {
     return NextResponse.next()
   }
 
+  // --- Rate-limit housekeeping ---
+  pruneRateLimitMap()
+
+  const clientIp = getClientIp(request)
+  const entry = rateLimitMap.get(clientIp)
+
+  // Check lockout before even validating the key
+  if (entry && entry.lockedUntil > Date.now()) {
+    const retryAfter = Math.ceil((entry.lockedUntil - Date.now()) / 1000)
+    return NextResponse.json(
+      { error: 'Too many failed attempts. Try again later.', retryAfter },
+      { status: 429, headers: { 'Retry-After': String(retryAfter) } },
+    )
+  }
+
   const providedKey =
     request.headers.get('x-access-key')
     || request.nextUrl.searchParams.get('key')
     || ''
 
   if (providedKey !== accessKey) {
-    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    // Record the failed attempt
+    const current = rateLimitMap.get(clientIp) ?? { count: 0, lockedUntil: 0 }
+    current.count += 1
+
+    if (current.count >= MAX_ATTEMPTS) {
+      current.lockedUntil = Date.now() + LOCKOUT_MS
+    }
+
+    rateLimitMap.set(clientIp, current)
+
+    const remaining = Math.max(0, MAX_ATTEMPTS - current.count)
+    return NextResponse.json(
+      { error: 'Unauthorized' },
+      { status: 401, headers: { 'X-RateLimit-Remaining': String(remaining) } },
+    )
+  }
+
+  // Successful auth — clear any prior failed-attempt tracking for this IP
+  if (entry) {
+    rateLimitMap.delete(clientIp)
   }
 
   return NextResponse.next()

package/src/stores/use-app-store.ts

@@ -1,7 +1,7 @@
 'use client'
 
 import { create } from 'zustand'
-import type { Sessions, Session, NetworkInfo, Directory, ProviderInfo, Credentials, Agent, Schedule, AppView, BoardTask, AppSettings, OrchestratorSecret, ProviderConfig, Skill, Connector, Webhook, McpServerConfig, PluginMeta, Project, FleetFilter, ActivityEntry } from '../types'
+import type { Sessions, Session, NetworkInfo, Directory, ProviderInfo, Credentials, Agent, Schedule, AppView, BoardTask, AppSettings, OrchestratorSecret, ProviderConfig, Skill, Connector, Webhook, McpServerConfig, PluginMeta, Project, FleetFilter, ActivityEntry, AppNotification } from '../types'
 import { fetchSessions, fetchDirs, fetchProviders, fetchCredentials } from '../lib/sessions'
 import { fetchAgents } from '../lib/agents'
 import { fetchSchedules } from '../lib/schedules'
@@ -53,6 +53,7 @@ interface AppState {
 
   agents: Record<string, Agent>
   loadAgents: () => Promise<void>
+  togglePinAgent: (id: string) => void
 
   schedules: Record<string, Schedule>
   loadSchedules: () => Promise<void>
@@ -180,10 +181,26 @@ interface AppState {
   fleetFilter: FleetFilter
   setFleetFilter: (filter: FleetFilter) => void
 
+  // Chat list filter
+  chatFilter: 'all' | 'active' | 'recent'
+  setChatFilter: (filter: 'all' | 'active' | 'recent') => void
+
   // Activity / Audit Trail
   activityEntries: ActivityEntry[]
   loadActivity: (filters?: { entityType?: string; limit?: number }) => Promise<void>
 
+  // Unread tracking (localStorage-backed)
+  lastReadTimestamps: Record<string, number>
+  markChatRead: (id: string) => void
+
+  // Notifications
+  notifications: AppNotification[]
+  unreadNotificationCount: number
+  loadNotifications: () => Promise<void>
+  markNotificationRead: (id: string) => Promise<void>
+  markAllNotificationsRead: () => Promise<void>
+  clearReadNotifications: () => Promise<void>
+
 }
 
 export const useAppStore = create<AppState>((set, get) => ({
@@ -192,7 +209,8 @@ export const useAppStore = create<AppState>((set, get) => ({
   hydrate: () => {
     if (typeof window === 'undefined') return
     const user = localStorage.getItem('sc_user')
-    set({ currentUser: user, _hydrated: true })
+    const savedAgentId = localStorage.getItem('sc_agent')
+    set({ currentUser: user, currentAgentId: savedAgentId, _hydrated: true })
   },
   setUser: (user) => {
     if (user) localStorage.setItem('sc_user', user)
@@ -297,16 +315,18 @@ export const useAppStore = create<AppState>((set, get) => ({
   newSessionOpen: false,
   setNewSessionOpen: (open) => set({ newSessionOpen: open }),
 
-  activeView: 'agents',
+  activeView: 'home',
   setActiveView: (view) => set({ activeView: view }),
 
   currentAgentId: null,
   setCurrentAgent: async (id) => {
     if (!id) {
       set({ currentAgentId: null })
+      if (typeof window !== 'undefined') localStorage.removeItem('sc_agent')
       return
     }
     set({ currentAgentId: id })
+    if (typeof window !== 'undefined') localStorage.setItem('sc_agent', id)
     try {
       const user = get().currentUser || 'default'
       const session = await api<Session>('POST', `/agents/${id}/thread`, { user })
@@ -328,6 +348,14 @@ export const useAppStore = create<AppState>((set, get) => ({
       // ignore
     }
   },
+  togglePinAgent: (id) => {
+    const agents = { ...get().agents }
+    if (agents[id]) {
+      agents[id] = { ...agents[id], pinned: !agents[id].pinned }
+      set({ agents })
+      void api('PUT', `/agents/${id}`, { pinned: agents[id].pinned })
+    }
+  },
 
   schedules: {},
   loadSchedules: async () => {
@@ -576,6 +604,10 @@ export const useAppStore = create<AppState>((set, get) => ({
   fleetFilter: 'all',
   setFleetFilter: (filter) => set({ fleetFilter: filter }),
 
+  // Chat list filter
+  chatFilter: 'all' as const,
+  setChatFilter: (filter) => set({ chatFilter: filter }),
+
   // Activity / Audit Trail
   activityEntries: [],
   loadActivity: async (filters) => {
@@ -591,4 +623,63 @@ export const useAppStore = create<AppState>((set, get) => ({
     }
   },
 
+  // Unread tracking
+  lastReadTimestamps: typeof window !== 'undefined'
+    ? (() => { try { return JSON.parse(localStorage.getItem('sc_last_read') || '{}') } catch { return {} } })()
+    : {},
+  markChatRead: (id) => {
+    const ts = { ...get().lastReadTimestamps, [id]: Date.now() }
+    set({ lastReadTimestamps: ts })
+    try { localStorage.setItem('sc_last_read', JSON.stringify(ts)) } catch { /* ignore */ }
+  },
+
+  // Notifications
+  notifications: [],
+  unreadNotificationCount: 0,
+  loadNotifications: async () => {
+    try {
+      const notifications = await api<AppNotification[]>('GET', '/notifications')
+      set({
+        notifications,
+        unreadNotificationCount: notifications.filter((n) => !n.read).length,
+      })
+    } catch {
+      // ignore
+    }
+  },
+  markNotificationRead: async (id) => {
+    const notifications = get().notifications.map((n) =>
+      n.id === id ? { ...n, read: true } : n,
+    )
+    set({
+      notifications,
+      unreadNotificationCount: notifications.filter((n) => !n.read).length,
+    })
+    try {
+      await api('PUT', `/notifications/${id}`, { read: true })
+    } catch {
+      // ignore
+    }
+  },
+  markAllNotificationsRead: async () => {
+    const notifications = get().notifications.map((n) => ({ ...n, read: true }))
+    set({ notifications, unreadNotificationCount: 0 })
+    try {
+      await Promise.all(
+        get().notifications.filter((n) => !n.read).map((n) => api('PUT', `/notifications/${n.id}`, { read: true })),
+      )
+    } catch {
+      // ignore
+    }
+  },
+  clearReadNotifications: async () => {
+    const notifications = get().notifications.filter((n) => !n.read)
+    set({ notifications, unreadNotificationCount: notifications.length })
+    try {
+      await api('DELETE', '/notifications')
+    } catch {
+      // ignore
+    }
+  },
+
 }))

package/src/stores/use-chat-store.ts

@@ -68,6 +68,10 @@ interface ChatState {
   pendingImage: PendingFile | null
   setPendingImage: (img: PendingFile | null) => void
 
+  // Reply-to
+  replyingTo: { message: Message; index: number } | null
+  setReplyingTo: (reply: { message: Message; index: number } | null) => void
+
   devServer: DevServerStatus | null
   setDevServer: (ds: DevServerStatus | null) => void
 
@@ -83,12 +87,22 @@ interface ChatState {
   sendHeartbeat: (sessionId: string) => Promise<void>
   stopStreaming: () => void
 
+  // Thinking/reasoning text during streaming
+  thinkingText: string
+  thinkingStartTime: number
+
   // Rich trace blocks during streaming (F13)
   streamTraces: ChatTraceBlock[]
 
   // Voice conversation
   voiceConversationActive: boolean
   onStreamEvent: ((event: { t: string; text?: string }) => void) | null
+
+  // Message queue (send while streaming)
+  queuedMessages: string[]
+  addQueuedMessage: (text: string) => void
+  removeQueuedMessage: (index: number) => void
+  shiftQueuedMessage: () => string | undefined
 }
 
 // Module-level cadence interval (not in state to avoid re-renders)
@@ -128,9 +142,21 @@ export const useChatStore = create<ChatState>((set, get) => ({
     setSoundEnabled(next)
     set({ soundEnabled: next })
   },
+  thinkingText: '',
+  thinkingStartTime: 0,
   streamTraces: [],
   voiceConversationActive: false,
   onStreamEvent: null,
+  queuedMessages: [],
+  addQueuedMessage: (text) => set((s) => ({ queuedMessages: [...s.queuedMessages, text] })),
+  removeQueuedMessage: (index) => set((s) => ({ queuedMessages: s.queuedMessages.filter((_, i) => i !== index) })),
+  shiftQueuedMessage: () => {
+    const q = get().queuedMessages
+    if (!q.length) return undefined
+    const next = q[0]
+    set({ queuedMessages: q.slice(1) })
+    return next
+  },
 
   pendingFiles: [],
   addPendingFile: (f) => set((s) => ({ pendingFiles: [...s.pendingFiles, f] })),
@@ -141,6 +167,10 @@ export const useChatStore = create<ChatState>((set, get) => ({
   get pendingImage() { const files = get().pendingFiles; return files.length ? files[0] : null },
   setPendingImage: (img) => set({ pendingFiles: img ? [img] : [] }),
 
+  // Reply-to
+  replyingTo: null,
+  setReplyingTo: (reply) => set({ replyingTo: reply }),
+
   previewContent: null,
   setPreviewContent: (content) => set({ previewContent: content }),
 
@@ -150,7 +180,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
   setDebugOpen: (open) => set({ debugOpen: open }),
 
   sendMessage: async (text: string) => {
-    const { pendingFiles } = get()
+    const { pendingFiles, replyingTo } = get()
     if ((!text.trim() && !pendingFiles.length) || get().streaming) return
     const sessionId = useAppStore.getState().currentSessionId
     if (!sessionId) return
@@ -162,6 +192,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
     const attachedFiles = pendingFiles.length > 1
       ? pendingFiles.map((f) => f.path)
       : undefined
+    const replyToId = replyingTo?.message?.replyToId ? undefined : replyingTo?.message ? `msg-${replyingTo.index}` : undefined
 
     const userMsg: Message = {
       role: 'user',
@@ -170,6 +201,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
       imagePath,
       imageUrl,
       attachedFiles,
+      ...(replyToId ? { replyToId } : {}),
     }
     clearCadence()
     set((s) => ({
@@ -180,8 +212,11 @@ export const useChatStore = create<ChatState>((set, get) => ({
       streamToolName: '',
       displayText: '',
       agentStatus: null,
+      thinkingText: '',
+      thinkingStartTime: Date.now(),
       messages: [...s.messages, userMsg],
       pendingFiles: [],
+      replyingTo: null,
       toolEvents: [],
       lastUsage: null,
     }))
@@ -296,6 +331,8 @@ export const useChatStore = create<ChatState>((set, get) => ({
           set({ streamText: fullText })
           if (get().soundEnabled) playError()
         }
+      } else if (event.t === 'thinking') {
+        set((s) => ({ thinkingText: s.thinkingText + (event.text || '') }))
       } else if (event.t === 'status') {
         try {
           const parsed = JSON.parse(event.text || '{}')
@@ -306,7 +343,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
       } else if (event.t === 'done') {
         // done
       }
-    }, attachedFiles)
+    }, attachedFiles, { replyToId })
 
     clearCadence()
     if (get().soundEnabled && soundFiredStart) playStreamEnd()
@@ -333,13 +370,21 @@ export const useChatStore = create<ChatState>((set, get) => ({
         displayText: '',
         streamPhase: 'thinking' as const,
         streamToolName: '',
+        thinkingText: '',
+        thinkingStartTime: 0,
       }))
       if (get().ttsEnabled && !get().voiceConversationActive) speak(fullText)
     } else {
-      set({ streaming: false, streamingSessionId: null, streamText: '', displayText: '', streamPhase: 'thinking' as const, streamToolName: '' })
+      set({ streaming: false, streamingSessionId: null, streamText: '', displayText: '', streamPhase: 'thinking' as const, streamToolName: '', thinkingText: '', thinkingStartTime: 0 })
     }
 
     useAppStore.getState().loadSessions()
+
+    // Auto-dequeue: if there are queued messages, send the next one
+    const nextQueued = get().shiftQueuedMessage()
+    if (nextQueued) {
+      setTimeout(() => get().sendMessage(nextQueued), 100)
+    }
   },
 
   editAndResend: async (messageIndex: number, newText: string) => {