bingocode 1.0.1 → 1.0.3

package/desktop/src/lib/__tests__/cronDescribe.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest'
+import { describeCron, isValidCron } from '../cronDescribe'
+
+// Simple mock t() that returns the key with params interpolated
+const t = (key: string, params?: Record<string, string | number>) => {
+  let text = key
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      text = text.replace(new RegExp(`\\{${k}\\}`, 'g'), String(v))
+    }
+  }
+  return text
+}
+
+describe('describeCron', () => {
+  it('every minute', () => {
+    expect(describeCron('* * * * *', t)).toBe('cron.everyMinute')
+  })
+
+  it('every N minutes', () => {
+    expect(describeCron('*/15 * * * *', t)).toBe('cron.everyNMinutes')
+    expect(describeCron('*/5 * * * *', t)).toBe('cron.everyNMinutes')
+  })
+
+  it('*/1 is treated as every minute', () => {
+    expect(describeCron('*/1 * * * *', t)).toBe('cron.everyMinute')
+  })
+
+  it('every hour', () => {
+    expect(describeCron('0 */1 * * *', t)).toBe('cron.everyHour')
+  })
+
+  it('every N hours', () => {
+    expect(describeCron('0 */4 * * *', t)).toBe('cron.everyNHours')
+  })
+
+  it('every N hours at minute offset', () => {
+    expect(describeCron('30 */4 * * *', t)).toBe('cron.everyNHoursAtMinute')
+  })
+
+  it('daily at time', () => {
+    expect(describeCron('30 9 * * *', t)).toBe('cron.dailyAt')
+  })
+
+  it('weekdays at time', () => {
+    expect(describeCron('30 9 * * 1-5', t)).toBe('cron.weekdaysAt')
+  })
+
+  it('specific days of week', () => {
+    const result = describeCron('0 9 * * 1,3,5', t)
+    expect(result).toBe('cron.specificDaysAt')
+  })
+
+  it('monthly on specific day', () => {
+    expect(describeCron('0 9 15 * *', t)).toBe('cron.monthlyAt')
+  })
+
+  it('unrecognized pattern falls back to custom', () => {
+    expect(describeCron('0 9 1 6 *', t)).toBe('cron.customSchedule')
+  })
+
+  it('invalid field count falls back to custom', () => {
+    expect(describeCron('0 9 *', t)).toBe('cron.customSchedule')
+  })
+})
+
+describe('isValidCron', () => {
+  it('accepts valid expressions', () => {
+    expect(isValidCron('0 9 * * *')).toBe(true)
+    expect(isValidCron('*/15 * * * *')).toBe(true)
+    expect(isValidCron('30 14 * * 1-5')).toBe(true)
+    expect(isValidCron('0 9 * * 1,3,5')).toBe(true)
+    expect(isValidCron('0 9 15 * *')).toBe(true)
+    expect(isValidCron('0 */2 * * *')).toBe(true)
+  })
+
+  it('rejects invalid expressions', () => {
+    expect(isValidCron('')).toBe(false)
+    expect(isValidCron('hello')).toBe(false)
+    expect(isValidCron('0 9 *')).toBe(false)  // too few fields
+    expect(isValidCron('0 9 * * * *')).toBe(false)  // too many fields
+    expect(isValidCron('60 9 * * *')).toBe(false)  // minute > 59
+    expect(isValidCron('0 25 * * *')).toBe(false)  // hour > 23
+    expect(isValidCron('0 9 32 * *')).toBe(false)  // day > 31
+    expect(isValidCron('0 9 * 13 *')).toBe(false)  // month > 12
+    expect(isValidCron('0 9 * * 8')).toBe(false)   // dow > 7
+  })
+
+  it('accepts edge case values', () => {
+    expect(isValidCron('0 0 1 1 0')).toBe(true)
+    expect(isValidCron('59 23 31 12 7')).toBe(true)
+  })
+})

package/desktop/src/lib/cronDescribe.ts

@@ -0,0 +1,188 @@
+/**
+ * Cron expression utilities: human-readable description & validation.
+ * Works with standard 5-field cron: minute hour day-of-month month day-of-week
+ */
+
+import type { TranslationKey } from '../i18n'
+
+type TFunc = (key: TranslationKey, params?: Record<string, string | number>) => string
+
+function pad(n: number): string {
+  return n.toString().padStart(2, '0')
+}
+
+function formatTime(hour: number, minute: number): string {
+  return `${pad(hour)}:${pad(minute)}`
+}
+
+function describeDow(field: string, t: TFunc): string {
+  const parts = field.split(',')
+  const days: number[] = []
+  for (const part of parts) {
+    const range = part.match(/^(\d+)-(\d+)$/)
+    if (range) {
+      const start = parseInt(range[1]!)
+      const end = parseInt(range[2]!)
+      for (let i = start; i <= end; i++) days.push(i)
+    } else {
+      days.push(parseInt(part))
+    }
+  }
+  return days.map((d) => t(`cron.dow.${d % 7}` as any)).join(', ') // dynamic key
+}
+
+export function describeCron(cron: string, t: TFunc): string {
+  const fields = cron.trim().split(/\s+/)
+  if (fields.length !== 5) return t('cron.customSchedule', { cron })
+
+  const min = fields[0]!
+  const hour = fields[1]!
+  const dom = fields[2]!
+  const month = fields[3]!
+  const dow = fields[4]!
+
+  // */N * * * * → every N minutes
+  if (hour === '*' && dom === '*' && month === '*' && dow === '*') {
+    const stepMatch = min.match(/^\*\/(\d+)$/)
+    if (stepMatch) {
+      const n = parseInt(stepMatch[1]!)
+      if (n === 1) return t('cron.everyMinute')
+      return t('cron.everyNMinutes', { n })
+    }
+    if (min === '*') return t('cron.everyMinute')
+  }
+
+  // M */N * * * → every N hours (optionally at :M)
+  if (/^\d+$/.test(min) && dom === '*' && month === '*' && dow === '*') {
+    const hourStep = hour.match(/^\*\/(\d+)$/)
+    if (hourStep) {
+      const n = parseInt(hourStep[1]!)
+      const m = parseInt(min)
+      if (m === 0) {
+        if (n === 1) return t('cron.everyHour')
+        return t('cron.everyNHours', { n })
+      }
+      return t('cron.everyNHoursAtMinute', { n, m: pad(m) })
+    }
+  }
+
+  // M H * * <dow> → daily / weekdays / specific days
+  if (/^\d+$/.test(min) && /^\d+$/.test(hour) && dom === '*' && month === '*') {
+    const time = formatTime(parseInt(hour), parseInt(min))
+
+    if (dow === '*') {
+      return t('cron.dailyAt', { time })
+    }
+    if (dow === '1-5') {
+      return t('cron.weekdaysAt', { time })
+    }
+    if (/^[\d,\-]+$/.test(dow)) {
+      const days = describeDow(dow, t)
+      return t('cron.specificDaysAt', { days, time })
+    }
+  }
+
+  // M H D * * → monthly on day D
+  if (/^\d+$/.test(min) && /^\d+$/.test(hour) && /^\d+$/.test(dom) && month === '*' && dow === '*') {
+    const time = formatTime(parseInt(hour), parseInt(min))
+    return t('cron.monthlyAt', { day: parseInt(dom), time })
+  }
+
+  return t('cron.customSchedule', { cron })
+}
+
+/**
+ * Reverse-parse a cron expression back into UI-friendly state
+ * for the task edit modal.
+ */
+export type FrequencyKey = 'everyNMinutes' | 'everyNHours' | 'daily' | 'weekdays' | 'specificDays' | 'monthly' | 'customCron'
+
+export type ParsedCron = {
+  frequency: FrequencyKey
+  time: string
+  minuteInterval: number
+  hourInterval: number
+  minuteOffset: number
+  selectedDays: number[]
+  monthDay: number
+  customCron: string
+}
+
+const DEFAULTS: ParsedCron = {
+  frequency: 'customCron',
+  time: '09:00',
+  minuteInterval: 15,
+  hourInterval: 1,
+  minuteOffset: 0,
+  selectedDays: [1],
+  monthDay: 1,
+  customCron: '',
+}
+
+export function parseCron(cron: string): ParsedCron {
+  const fields = cron.trim().split(/\s+/)
+  if (fields.length !== 5) return { ...DEFAULTS, customCron: cron }
+
+  const min = fields[0]!
+  const hour = fields[1]!
+  const dom = fields[2]!
+  const month = fields[3]!
+  const dow = fields[4]!
+
+  // */N * * * * → everyNMinutes
+  if (/^\*\/\d+$/.test(min) && hour === '*' && dom === '*' && month === '*' && dow === '*') {
+    return { ...DEFAULTS, frequency: 'everyNMinutes', minuteInterval: parseInt(min.split('/')[1]!) }
+  }
+
+  // M */N * * * → everyNHours
+  if (/^\d+$/.test(min) && /^\*\/\d+$/.test(hour) && dom === '*' && month === '*' && dow === '*') {
+    return { ...DEFAULTS, frequency: 'everyNHours', minuteOffset: parseInt(min), hourInterval: parseInt(hour.split('/')[1]!) }
+  }
+
+  // M H ... patterns need time
+  if (/^\d+$/.test(min) && /^\d+$/.test(hour)) {
+    const time = formatTime(parseInt(hour), parseInt(min))
+
+    // M H * * * → daily
+    if (dom === '*' && month === '*' && dow === '*') {
+      return { ...DEFAULTS, frequency: 'daily', time }
+    }
+    // M H * * 1-5 → weekdays
+    if (dom === '*' && month === '*' && dow === '1-5') {
+      return { ...DEFAULTS, frequency: 'weekdays', time }
+    }
+    // M H * * <list> → specificDays
+    if (dom === '*' && month === '*' && /^[\d,]+$/.test(dow)) {
+      return { ...DEFAULTS, frequency: 'specificDays', time, selectedDays: dow.split(',').map(Number) }
+    }
+    // M H D * * → monthly
+    if (/^\d+$/.test(dom) && month === '*' && dow === '*') {
+      return { ...DEFAULTS, frequency: 'monthly', time, monthDay: parseInt(dom) }
+    }
+  }
+
+  return { ...DEFAULTS, customCron: cron }
+}
+
+export function isValidCron(cron: string): boolean {
+  const fields = cron.trim().split(/\s+/)
+  if (fields.length !== 5) return false
+
+  const fieldPattern = /^(\*|(\d+(-\d+)?(\/\d+)?)(,(\d+(-\d+)?(\/\d+)?))*)$/
+  const maxValues = [59, 23, 31, 12, 7]
+  const minValues = [0, 0, 1, 1, 0]
+
+  for (let i = 0; i < 5; i++) {
+    const field = fields[i]!
+    if (/^\*\/\d+$/.test(field)) continue
+    if (field === '*') continue
+    if (!fieldPattern.test(field)) return false
+    const nums = field.replace(/\/\d+/g, '').split(/[,\-]/).filter((s) => /^\d+$/.test(s))
+    for (const num of nums) {
+      const n = parseInt(num)
+      if (n < minValues[i]! || n > maxValues[i]!) return false
+    }
+  }
+
+  return true
+}

package/desktop/src/lib/desktopRuntime.ts

@@ -0,0 +1,54 @@
+import { getDefaultBaseUrl, setBaseUrl } from '../api/client'
+
+export function isTauriRuntime() {
+  if (typeof window === 'undefined') return false
+  return '__TAURI_INTERNALS__' in window || '__TAURI__' in window
+}
+
+export async function initializeDesktopServerUrl() {
+  const fallbackUrl = getDefaultBaseUrl()
+
+  if (!isTauriRuntime()) {
+    setBaseUrl(fallbackUrl)
+    return fallbackUrl
+  }
+
+  try {
+    const { invoke } = await import(/* @vite-ignore */ '@tauri-apps/api/core')
+    const serverUrl = await invoke<string>('get_server_url')
+    setBaseUrl(serverUrl)
+    await waitForHealth(serverUrl)
+    return serverUrl
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : `desktop server startup failed: ${String(error)}`
+    console.error('[desktop] Failed to initialize desktop server URL', error)
+    throw new Error(message || `desktop server startup failed (fallback would be ${fallbackUrl})`)
+  }
+}
+
+async function waitForHealth(serverUrl: string) {
+  let lastError: unknown
+
+  for (let attempt = 0; attempt < 30; attempt++) {
+    try {
+      const response = await fetch(`${serverUrl}/health`, {
+        cache: 'no-store',
+      })
+      if (response.ok) {
+        return
+      }
+      lastError = new Error(`healthcheck returned ${response.status}`)
+    } catch (error) {
+      lastError = error
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 250))
+  }
+
+  throw new Error(
+    lastError instanceof Error
+      ? `Local server healthcheck failed: ${lastError.message}`
+      : 'Local server healthcheck failed',
+  )
+}

package/desktop/src/lib/parseRunOutput.ts

@@ -0,0 +1,79 @@
+/**
+ * Parse task run output into displayable text.
+ *
+ * The output may be in one of two formats:
+ *
+ * 1. **Extracted text** (new runs) — The server's `extractAssistantText` has
+ *    already parsed the raw NDJSON and stored only the AI's text response.
+ *    This is plain text / markdown that should be returned as-is.
+ *
+ * 2. **Raw NDJSON** (old runs before the server-side extraction was added) —
+ *    Each line is a JSON object from the CLI's stream-json output. We parse
+ *    these and extract assistant text blocks + result messages.
+ *
+ * Detection: if at least one line parses as JSON with a recognized `type`
+ * field, treat as NDJSON. Otherwise return as-is.
+ */
+export function parseRunOutput(raw: string): string {
+  if (!raw || !raw.trim()) return ''
+
+  const lines = raw.trim().split('\n')
+
+  // Quick check: does this look like NDJSON? (first non-empty line starts with '{')
+  const firstLine = lines.find((l) => l.trim())
+  if (!firstLine || !firstLine.trim().startsWith('{')) {
+    // Already extracted plain text — return as-is
+    return raw.trim()
+  }
+
+  // Try to parse as NDJSON (legacy format)
+  const textParts: string[] = []
+  let anyRecognized = false
+
+  for (const line of lines) {
+    if (!line.trim()) continue
+
+    let parsed: any
+    try {
+      parsed = JSON.parse(line)
+    } catch {
+      continue
+    }
+
+    const type = parsed?.type
+
+    if (type === 'assistant') {
+      anyRecognized = true
+      const content = parsed?.message?.content
+      if (!Array.isArray(content)) continue
+      for (const block of content) {
+        if (block.type === 'text' && block.text?.trim()) {
+          textParts.push(block.text.trim())
+        }
+      }
+    }
+
+    if (type === 'result') {
+      anyRecognized = true
+      const result = parsed?.result
+      if (typeof result === 'string' && result.trim()) {
+        textParts.push(result.trim())
+      } else if (result?.message?.trim()) {
+        textParts.push(result.message.trim())
+      }
+    }
+
+    if (type === 'system' || type === 'user') {
+      anyRecognized = true
+      // Skip these — not useful to display
+    }
+  }
+
+  // If we recognized NDJSON structure, return extracted text
+  if (anyRecognized) {
+    return textParts.join('\n\n')
+  }
+
+  // Fallback: the JSON lines didn't have recognized types — return raw
+  return raw.trim()
+}

package/desktop/src/main.tsx

@@ -0,0 +1,13 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import { App } from './App'
+import './theme/globals.css'
+import { initializeTheme } from './stores/uiStore'
+
+initializeTheme()
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)

package/desktop/src/mocks/data.ts

@@ -0,0 +1,202 @@
+/**
+ * Mock data for all pages — matches the UI prototypes exactly.
+ * Replace with real API calls once server integration is done.
+ */
+
+// ─── Sessions ─────────────────────────────────────────────────────
+export const mockSessions = {
+  today: [
+    { id: 's1', title: 'Refactor login flow', modifiedAt: new Date().toISOString() },
+    { id: 's2', title: 'Fix CSS responsive layout', modifiedAt: new Date().toISOString() },
+  ],
+  previous7Days: [
+    { id: 's3', title: 'Add user authentication', modifiedAt: new Date(Date.now() - 3 * 86400000).toISOString() },
+    { id: 's4', title: 'Database migration script', modifiedAt: new Date(Date.now() - 5 * 86400000).toISOString() },
+  ],
+  older: [
+    { id: 's5', title: 'Initial project setup', modifiedAt: new Date(Date.now() - 30 * 86400000).toISOString() },
+  ],
+}
+
+// ─── Active Session Messages ──────────────────────────────────────
+export const mockActiveMessages = [
+  {
+    id: 'm1',
+    role: 'user' as const,
+    content: "I want to refactor the login flow in `auth.ts`. Let's move the JWT signing logic to a separate helper and add validation for the user payload.",
+  },
+  {
+    id: 'm2',
+    role: 'assistant' as const,
+    content: "Understood. I will begin by analyzing the current implementation of `auth.ts`. I'll extract the JWT logic into a new utility function and implement the validation layer as requested.",
+    thinking: "Looking at the auth.ts file, the JWT signing is currently inline in the login handler. I need to:\n1. Extract signToken() helper\n2. Add Zod validation for LoginPayload\n3. Update the handler to use both",
+  },
+  {
+    id: 'm3',
+    role: 'tool' as const,
+    toolName: 'edit_file',
+    toolStatus: 'success',
+    filePath: 'src/lib/auth.ts',
+    content: `export const validatePayload = (user) => { ... }
+export const signToken = (payload) => jwt.sign(payload, SECRET);
+// 8 OLD LINES REMOVED`,
+  },
+]
+
+// ─── Agent Teams ──────────────────────────────────────────────────
+export const mockTeam = {
+  name: 'session-dev',
+  memberCount: 4,
+  members: [
+    { id: 'a1', role: 'Architect', status: 'completed' as const, color: '#16a34a' },
+    { id: 'a2', role: 'Frontend Dev', status: 'running' as const, color: '#dc2626' },
+    { id: 'a3', role: 'Backend Dev', status: 'running' as const, color: '#2563eb' },
+    { id: 'a4', role: 'Tester', status: 'idle' as const, color: '#9333ea' },
+  ],
+}
+
+export const mockTeamMessages = {
+  userMessage: "Refactor the authentication middleware to support JWT and OAuth2 simultaneously. Ensure we have proper test coverage for the edge cases.",
+  assistantMessage: "I've initiated the agent team for this task. The architect is designing the interface, while the developers are preparing the boilerplate for the new strategies.",
+  systemInfo: `Info: spawning child_processes for parallel development
+active: session-dev cluster initiated
+ready: 4 agents assigned`,
+}
+
+// ─── Agent Transcript ─────────────────────────────────────────────
+export const mockTranscript = {
+  agentName: 'Frontend Dev',
+  messages: [
+    {
+      id: 't1',
+      role: 'agent' as const,
+      timestamp: 'P1:42:11',
+      content: "I've analyzed the component structure. I need to update the `Navigation.tsx` to include the new responsive breakpoints. Initiating local file system audit.",
+    },
+    {
+      id: 't2',
+      role: 'tool' as const,
+      toolName: 'BASH',
+      status: 'SUCCESS' as const,
+      command: '$ grep -r "breakpoint" .\n./Navigation.tsx: const [isMobile, setIsMobile] = useState(false);\n./Navigation.tsx: // TODO: Add mobile breakpoint check\n./Header.tsx: @media (max-width: 768px) {',
+    },
+    {
+      id: 't3',
+      role: 'progress' as const,
+      label: 'Patching Navigation.tsx',
+      progress: 67,
+    },
+    {
+      id: 't4',
+      role: 'agent' as const,
+      timestamp: 'P1:44:35',
+      content: "Breakpoint logic implemented. I'm now verifying the CSS-in-JS injection to ensure no style collisions with the existing theme.",
+      images: ['/placeholder-code-1.jpg', '/placeholder-code-2.jpg'],
+    },
+  ],
+  teamBar: [
+    { id: 'lead', role: 'Lead Claude', active: false, color: '#87736D' },
+    { id: 'a2', role: 'Frontend Dev', active: true, color: '#dc2626' },
+    { id: 'a3', role: 'Backend Architect', active: false, color: '#2563eb' },
+  ],
+}
+
+// ─── Scheduled Tasks ──────────────────────────────────────────────
+export const mockScheduledTasks = {
+  stats: {
+    totalTasks: 12,
+    activeHealthy: 9,
+    nextRun: { name: 'Nightly linting', time: 'Today, 11:30 PM' },
+    systemHealth: 99.8,
+    healthPeriod: 'Last 30 days execution rate',
+  },
+  tasks: [
+    {
+      id: 'task1',
+      name: 'Nightly linting',
+      frequency: 'Daily',
+      lastResult: 'Success' as const,
+      nextExecution: 'Today, 11:30 PM',
+    },
+    {
+      id: 'task2',
+      name: 'Clean up temp files',
+      description: 'Clean TempOutput/**',
+      frequency: 'Weekly',
+      lastResult: 'Success' as const,
+      nextExecution: 'Sun, 2:00 AM',
+    },
+    {
+      id: 'task3',
+      name: 'Database Vacuum',
+      description: 'Postgres maintenance',
+      frequency: 'Monthly',
+      lastResult: 'Failed (Disk Full)' as const,
+      nextExecution: 'Dec 01, 9:01 AM',
+    },
+  ],
+}
+
+// ─── Session Controls ─────────────────────────────────────────────
+export const mockPermissionModes = [
+  { id: 'ask', label: 'Ask permissions', description: 'Confirm every file edit or terminal command.', icon: 'lock' },
+  { id: 'auto', label: 'Auto accept edits', description: 'Claude writes to disk without asking.', icon: 'edit_note' },
+  { id: 'plan', label: 'Plan mode', description: 'Architecture & reasoning only. No writes.', icon: 'architecture' },
+  { id: 'bypass', label: 'Bypass permissions', description: 'Full root access for shell and file system.', icon: 'warning' },
+]
+
+export const mockModels = [
+  { id: 'opus', name: 'Opus 4.7', active: false },
+  { id: 'sonnet', name: 'Sonnet 4.6', active: true },
+  { id: 'haiku', name: 'Haiku 4.5', active: false },
+]
+
+export const mockEffortLevels = ['Low', 'Medium', 'High', 'Max']
+
+// ─── Tool Inspection (edit_file diff) ─────────────────────────────
+export const mockToolInspection = {
+  toolType: 'TOOL CALL',
+  toolName: 'edit_file',
+  description: 'Updating login logic to use new SDK',
+  filePath: 'src/lib/auth.ts',
+  dryRunStatus: 'Dry-run Success',
+  linesChanged: { added: 12, removed: 8 },
+  diffLines: [
+    { type: 'context' as const, lineNo: 1, content: 'export async function loginCredentials: LoginCredentials): Promise<LoginResponse> {' },
+    { type: 'context' as const, lineNo: 2, content: '  try {' },
+    { type: 'removed' as const, lineNo: 3, content: '    const response = await legacyHttpClient.authenticate()' },
+    { type: 'added' as const, lineNo: 3, content: '    const response = await httpClient.authenticate({' },
+    { type: 'added' as const, lineNo: 4, content: '      user: credentials.username,' },
+    { type: 'added' as const, lineNo: 5, content: '      pass: credentials.password,' },
+    { type: 'context' as const, lineNo: 6, content: '    })' },
+    { type: 'context' as const, lineNo: 7, content: '' },
+    { type: 'removed' as const, lineNo: 8, content: '    const client = await createClient();' },
+    { type: 'added' as const, lineNo: 8, content: '    const client = await newSdkClient.create({' },
+    { type: 'added' as const, lineNo: 9, content: '      identifier: credentials.username,' },
+    { type: 'added' as const, lineNo: 10, content: '      secret: credentials.password,' },
+    { type: 'context' as const, lineNo: 11, content: '' },
+    { type: 'added' as const, lineNo: 12, content: '      options: { persistent: true }' },
+    { type: 'context' as const, lineNo: 13, content: '    })' },
+    { type: 'context' as const, lineNo: 14, content: '' },
+    { type: 'context' as const, lineNo: 15, content: '    if (response.status === 200) {' },
+    { type: 'context' as const, lineNo: 16, content: '      return response.data;' },
+  ],
+}
+
+// ─── New Task Modal ───────────────────────────────────────────────
+export const mockNewTaskDefaults = {
+  permissionModes: ['Restricted', 'Standard', 'Full Access'],
+  models: ['Claude 3.5 Sonnet', 'Claude 3.5 Haiku', 'Claude 3.5 Opus'],
+  frequencies: ['Hourly', 'Daily at 9:00 AM', 'Weekly', 'Monthly', 'Custom cron'],
+}
+
+// ─── Footer / Status Bar ──────────────────────────────────────────
+export const mockStatusBar = {
+  user: 'User Avatar',
+  username: 'username',
+  plan: 'Pro Plan',
+  branch: 'main-branch',
+  worktreeToggle: 'worktree-toggle',
+  localSwitch: 'local-switch',
+  status: 'Ready',
+}