@spacek33z/autoauto 0.0.1

package/src/lib/system-prompts/update.ts

@@ -0,0 +1,188 @@
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+import { getProgramsDir } from "../programs.ts"
+
+const VALIDATE_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), "..", "validate-measurement.ts")
+
+export interface UpdatePromptResult {
+  systemPrompt: string
+  referencePath: string
+  referenceContent: string
+}
+
+/**
+ * Builds the system prompt for the Update Agent.
+ * Reads and embeds current program files so the agent has full context.
+ */
+export async function getUpdateSystemPrompt(
+  cwd: string,
+  programSlug: string,
+  programDir: string,
+): Promise<UpdatePromptResult> {
+  const programsDir = getProgramsDir(cwd)
+  const referencePath = join(cwd, ".autoauto", "update-reference.md")
+
+  const [programMd, measureSh, configJson, buildSh] = await Promise.all([
+    Bun.file(join(programDir, "program.md")).text().catch(() => "(not found)"),
+    Bun.file(join(programDir, "measure.sh")).text().catch(() => "(not found)"),
+    Bun.file(join(programDir, "config.json")).text().catch(() => "(not found)"),
+    Bun.file(join(programDir, "build.sh")).text().catch(() => null),
+  ])
+
+  const systemPrompt = `You are the AutoAuto Update Agent — an expert at diagnosing and fixing autonomous experiment programs.
+
+## Your Role
+
+You help users fix and improve an existing optimization program. A program consists of a measurement script (measure.sh), a program definition (program.md), a config (config.json), and optionally a build script (build.sh). You analyze previous run results, diagnose issues, and propose targeted fixes.
+
+## Context
+
+Working directory: ${cwd}
+Program: ${programSlug}
+Program directory: ${programDir}
+
+## Current Program Files
+
+### program.md
+\`\`\`markdown
+${programMd}
+\`\`\`
+
+### measure.sh
+\`\`\`bash
+${measureSh}
+\`\`\`
+
+### config.json
+\`\`\`json
+${configJson}
+\`\`\`
+${buildSh ? `\n### build.sh\n\`\`\`bash\n${buildSh}\n\`\`\`\n` : ""}
+## Capabilities
+
+You can read files, search the codebase, list directories, run shell commands, write files, and edit files. You may freely READ any file in the project, but you may only WRITE/EDIT files inside .autoauto/programs/${programSlug}/. Do not modify target project source files — those are changed exclusively through the experiment loop.
+
+## Conversation Flow
+
+1. **Analyze** — The user's first message contains run results, error details, and experiment logs from the most recent run. Study this data carefully. Look for:
+   - Measurement failures (measure.sh errors, missing dependencies, broken paths)
+   - Config issues (noise_threshold too low, wrong direction, missing quality gates)
+   - Scope problems (program.md too broad/narrow, missing rules)
+   - Stagnation patterns (agent stuck in a loop, no improvement headroom)
+   - Crashes (agent errors, tool failures)
+   - Target project issues (broken build, missing files the measurement depends on)
+
+2. **Propose** — Present your analysis and specific proposed fixes. Be concrete: say exactly which file(s) you'd change and what you'd change. **Wait for the user to approve before making any changes.**
+
+3. **Fix** — After the user agrees (or guides you to a different fix), make the changes to the program files in .autoauto/programs/${programSlug}/.
+
+4. **Validate** — After modifying program files, read ${referencePath} for validation instructions, then run measurement validation to confirm the fix works.
+
+5. **Iterate** — If the user wants more changes, continue the conversation. When done, say: "Program updated. Press Escape to go back."
+
+## Key Principles
+
+- **Diagnose before fixing.** Read the run context carefully. Don't jump to changes without understanding the root cause.
+- **Propose, then wait.** Always present your proposed fix and wait for the user to confirm before editing files.
+- **One fix at a time.** Focus on the most impactful issue first.
+- **Validate after changes.** Always run measurement validation after modifying measure.sh, build.sh, or config.json.
+- **Be concise.** Don't lecture. Short, actionable responses.
+
+## What NOT to Do
+
+- Don't make changes without user approval
+- Don't modify target project source files — only edit files in .autoauto/programs/${programSlug}/
+- Don't skip measurement validation after modifying measurement files
+- Don't include anything other than JSON in measure.sh's stdout — logs go to stderr
+- Don't use \`mktemp\` with suffixes after the X template (e.g. \`mktemp /tmp/foo-XXXXXX.json\`) — this fails on macOS. Instead, append the suffix outside: \`$(mktemp /tmp/foo-XXXXXX).json\`
+- Don't forget to chmod +x measure.sh after writing it`
+
+  const referenceContent = `# Update Agent Reference
+
+This file contains validation procedures and artifact format reference for the AutoAuto Update Agent.
+
+**Paths:**
+- Programs directory: ${programsDir}
+- Program directory: ${programDir}
+- Validation script: ${VALIDATE_SCRIPT}
+
+## Measurement Validation
+
+After modifying measure.sh, build.sh, or config.json, ALWAYS validate measurement stability.
+
+### Running Validation
+
+Run this exact command via Bash:
+\`\`\`bash
+bun run ${VALIDATE_SCRIPT} ${programDir}/measure.sh ${programDir}/config.json 5
+\`\`\`
+
+The validation script:
+- Creates a temporary git worktree (simulating the actual run environment)
+- Runs build.sh once first if ${programDir}/build.sh exists
+- Runs 1 warmup measurement (excluded from stats)
+- Runs 5 measurement repeats sequentially
+- Validates every output against config.json
+- Computes variance statistics and avg_duration_ms
+- Outputs a JSON object with the full results
+- Automatically cleans up the worktree afterward
+
+**IMPORTANT:** build.sh MUST install any required dependencies (e.g. \`npm ci\`, \`bun install\`). If build.sh fails with "command not found" errors, the build script needs to install dependencies first.
+
+### Interpreting Results
+
+| CV% | Assessment | Action |
+|-----|-----------|--------|
+| < 1% | Deterministic | noise_threshold=0.01, repeats=1 |
+| 1–5% | Excellent | noise_threshold=0.02, repeats=3 |
+| 5–15% | Acceptable | noise_threshold=max(CV%*1.5/100, 0.05), repeats=5 |
+| 15–30% | Noisy | noise_threshold=max(CV%*2/100, 0.10), repeats=7 |
+| ≥ 30% | Unstable | Fix the measurement first |
+
+### Common Noise Causes & Fixes
+
+1. **Cold starts** — Add a warmup run excluded from measurement
+2. **Background processes** — Measure relative to baseline, not absolute
+3. **Network calls** — Mock external calls or use local servers
+4. **Non-deterministic code** — Lock random seeds, fix ordering
+5. **Caching** — Always warm or always clear caches
+6. **Shared state** — Clean up between measurement runs
+7. **Short measurement duration** — Increase sample size
+
+After fixing, re-run validation.
+
+## Artifact Formats
+
+When editing program files, follow these format requirements:
+
+### measure.sh
+- Shebang: \`#!/usr/bin/env bash\`
+- \`set -euo pipefail\`
+- stdout: exactly ONE JSON object, nothing else
+- stderr: OK for logs/debug output
+- Exit 0 on success, nonzero on failure
+- Must complete in <60 seconds
+- NEVER hardcode absolute home directory paths — use relative paths, \`$HOME\`, or \`~\`
+
+### config.json
+- \`metric_field\`: key from measure.sh JSON output
+- \`direction\`: "lower" or "higher"
+- \`noise_threshold\`: decimal (e.g. 0.02 for 2%), must exceed noise floor
+- \`repeats\`: integer ≥ 1
+- \`quality_gates\`: object with field: {min/max: number}
+- \`secondary_metrics\`: optional, field: {direction: "lower"|"higher"}
+
+### program.md
+- Sections: Goal, Scope (Files/Off-limits), Rules, Steps
+- Scope should be tight — one file or component is ideal
+- Rules should prevent metric gaming
+
+### build.sh (optional)
+- Shebang: \`#!/usr/bin/env bash\`
+- \`set -euo pipefail\`
+- Runs ONCE before measurement
+- Must install dependencies
+- NEVER hardcode absolute home directory paths`
+
+  return { systemPrompt, referencePath, referenceContent }
+}

package/src/lib/tool-events.ts

@@ -0,0 +1,99 @@
+function abbreviatePath(filePath: string): string {
+  const parts = filePath.replace(/^\//, "").split("/")
+  if (parts.length <= 3) return parts.join("/")
+  return `…/${parts.slice(-3).join("/")}`
+}
+
+function formatFileToolEvent(verb: string, input: Record<string, unknown>): string {
+  const filePath = input.file_path
+  if (typeof filePath === "string") {
+    // Multiple file changes (Codex file_change items)
+    const changes = input.changes
+    if (Array.isArray(changes) && changes.length > 1) {
+      return `${verb} ${abbreviatePath(filePath)} (+${changes.length - 1} more)`
+    }
+    return `${verb} ${abbreviatePath(filePath)}`
+  }
+  return `${verb} file...`
+}
+
+/** Canonical tool name map (lowercase → switch key) */
+const TOOL_ALIASES: Record<string, string> = {
+  read: "Read",
+  write: "Write",
+  edit: "Edit",
+  glob: "Glob",
+  grep: "Grep",
+  bash: "Bash",
+  list: "List",
+  apply_patch: "Edit",
+  multiedit: "Edit",
+  webfetch: "WebFetch",
+  websearch: "WebSearch",
+}
+
+function canonicalToolName(toolName: string): string {
+  return TOOL_ALIASES[toolName.toLowerCase()] ?? TOOL_ALIASES[toolName] ?? toolName
+}
+
+/** Format a tool call into a brief human-readable status string */
+export function formatToolEvent(
+  toolName: string,
+  input: Record<string, unknown>
+): string {
+  // Provider-supplied title takes precedence (e.g. OpenCode state.title)
+  const title = input.__title
+  if (typeof title === "string" && title.trim()) return title
+
+  const canonical = canonicalToolName(toolName)
+  switch (canonical) {
+    case "Read":
+      return formatFileToolEvent("Reading", input)
+    case "Write":
+      return formatFileToolEvent("Writing", input)
+    case "Edit":
+      return formatFileToolEvent("Editing", input)
+    case "List":
+      return "Listing directory..."
+    case "Glob": {
+      const pattern = input.pattern
+      if (typeof pattern === "string") {
+        return `Searching for ${pattern}`
+      }
+      return "Searching files..."
+    }
+    case "Grep": {
+      const pattern = input.pattern
+      const path = input.path
+      if (typeof pattern === "string") {
+        const suffix = typeof path === "string" ? ` in ${abbreviatePath(path)}` : ""
+        return `Grep: ${pattern}${suffix}`
+      }
+      return "Searching content..."
+    }
+    case "Bash": {
+      const command = input.command
+      if (typeof command === "string") {
+        if (command.includes("validate-measurement")) {
+          return "Validating measurement stability — this may take a minute"
+        }
+        if (command.includes("build.sh")) {
+          return "Running build step"
+        }
+        if (command.includes("measure.sh")) {
+          return "Running measurement"
+        }
+        const truncated =
+          command.length > 80 ? `${command.slice(0, 77)}...` : command
+        return `$ ${truncated}`
+      }
+      return "Running command..."
+    }
+    case "WebFetch":
+      return "Fetching web content..."
+    case "WebSearch":
+      return "Searching the web..."
+    default:
+      return `Using ${toolName}...`
+  }
+}

package/src/lib/validate-measurement.ts

@@ -0,0 +1,326 @@
+#!/usr/bin/env bun
+/* eslint-disable no-console, no-await-in-loop */
+import { existsSync, readFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { $ } from "bun"
+import { validateProgramConfig, type ProgramConfig } from "./programs.ts"
+import {
+  runBuild,
+  runMeasurement as runMeasurementCore,
+  validateMeasurementOutput,
+} from "./measure.ts"
+import { removeWorktree } from "./worktree.ts"
+
+interface RunResult {
+  run: number
+  success: boolean
+  output?: Record<string, unknown>
+  error?: string
+  duration_ms: number
+}
+
+interface FieldStats {
+  field: string
+  values: number[]
+  median: number
+  mean: number
+  min: number
+  max: number
+  stdev: number
+  cv_percent: number
+}
+
+type Assessment = "deterministic" | "excellent" | "acceptable" | "noisy" | "unstable"
+
+interface ValidationOutput {
+  success: boolean
+  total_runs: number
+  valid_runs: number
+  failed_runs: Array<{ run: number; error: string }>
+  validation_errors: Array<{ run: number; errors: string[] }>
+  metric: FieldStats | null
+  quality_gates: Record<string, FieldStats>
+  secondary_metrics: Record<string, FieldStats>
+  assessment: Assessment | null
+  recommendations: {
+    noise_threshold: number
+    repeats: number
+  } | null
+  avg_duration_ms: number
+  build: {
+    ran: boolean
+    success: boolean
+    duration_ms: number
+    error?: string
+  }
+}
+
+// --- Input Parsing ---
+
+const [measureShPath, configJsonPath, runsStr] = process.argv.slice(2)
+
+if (!measureShPath || !configJsonPath) {
+  console.error("Usage: validate-measurement.ts <measure_sh> <config_json> [runs]")
+  process.exit(1)
+}
+
+const numRuns = parseInt(runsStr || "5", 10)
+// Resolve cwd from measure.sh's location — go up from .autoauto/programs/<slug>/
+// to the project root.
+const projectRoot = dirname(dirname(dirname(dirname(measureShPath))))
+
+// --- Config Parsing ---
+
+let config: ProgramConfig
+try {
+  config = validateProgramConfig(JSON.parse(readFileSync(configJsonPath, "utf-8")))
+} catch (err) {
+  console.log(JSON.stringify({ success: false, error: `Failed to read config.json: ${err}` }))
+  process.exit(0)
+}
+
+// --- Measurement Execution ---
+
+async function runMeasurement(scriptPath: string, run: number, cwd: string): Promise<RunResult> {
+  const result = await runMeasurementCore(scriptPath, cwd)
+  if (result.success) {
+    return { run, success: true, output: result.output, duration_ms: result.duration_ms }
+  }
+  return { run, success: false, error: result.error, duration_ms: result.duration_ms }
+}
+
+// --- Field Validation ---
+
+function validateOutput(
+  output: Record<string, unknown>,
+  cfg: ProgramConfig,
+): { valid: boolean; errors: string[] } {
+  return validateMeasurementOutput(output, cfg)
+}
+
+// --- Statistics ---
+
+function round(n: number, decimals: number): number {
+  const factor = 10 ** decimals
+  return Math.round(n * factor) / factor
+}
+
+function computeStats(field: string, values: number[]): FieldStats {
+  const sorted = [...values].toSorted((a, b) => a - b)
+  const n = sorted.length
+  const median =
+    n % 2 === 0 ? (sorted[n / 2 - 1] + sorted[n / 2]) / 2 : sorted[Math.floor(n / 2)]
+  const mean = values.reduce((a, b) => a + b, 0) / n
+  const min = sorted[0]
+  const max = sorted[n - 1]
+  const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / (n - 1) // sample variance
+  const stdev = Math.sqrt(variance)
+  const cv_percent = mean !== 0 ? (stdev / Math.abs(mean)) * 100 : Infinity
+
+  return {
+    field,
+    values,
+    median: round(median, 4),
+    mean: round(mean, 4),
+    min: round(min, 4),
+    max: round(max, 4),
+    stdev: round(stdev, 4),
+    cv_percent: round(cv_percent, 2),
+  }
+}
+
+// --- Assessment & Recommendations ---
+
+function assess(cv_percent: number): Assessment {
+  if (cv_percent < 1) return "deterministic"
+  if (cv_percent < 5) return "excellent"
+  if (cv_percent < 15) return "acceptable"
+  if (cv_percent < 30) return "noisy"
+  return "unstable"
+}
+
+function recommend(cv_percent: number): { noise_threshold: number; repeats: number } {
+  if (cv_percent < 1) {
+    return { noise_threshold: 0.01, repeats: 1 }
+  }
+  if (cv_percent < 5) {
+    return { noise_threshold: 0.02, repeats: 3 }
+  }
+  if (cv_percent < 15) {
+    return {
+      noise_threshold: round(Math.max((cv_percent * 1.5) / 100, 0.05), 2),
+      repeats: 5,
+    }
+  }
+  if (cv_percent < 30) {
+    return {
+      noise_threshold: round(Math.max((cv_percent * 2) / 100, 0.1), 2),
+      repeats: 7,
+    }
+  }
+  // Unstable — don't recommend config, fix the measurement first
+  return { noise_threshold: -1, repeats: -1 }
+}
+
+// --- Main ---
+
+async function createValidationWorktree(root: string): Promise<string> {
+  const worktreePath = join(root, ".autoauto", "worktrees", `validate-${Date.now()}`)
+  await $`git worktree add --detach ${worktreePath}`.cwd(root).quiet()
+  return worktreePath
+}
+
+async function main() {
+  const buildShPath = join(dirname(measureShPath), "build.sh")
+
+  process.stderr.write("Creating validation worktree...\n")
+  let worktreePath: string
+  try {
+    worktreePath = await createValidationWorktree(projectRoot)
+  } catch (err) {
+    console.log(JSON.stringify({ success: false, error: `Failed to create validation worktree: ${err}` }))
+    return
+  }
+  process.stderr.write(`Worktree: ${worktreePath}\n`)
+
+  try {
+    await runInWorktree(worktreePath, buildShPath)
+  } finally {
+    process.stderr.write("Cleaning up validation worktree...\n")
+    await removeWorktree(projectRoot, worktreePath)
+  }
+}
+
+async function runInWorktree(
+  cwd: string,
+  buildShPath: string,
+) {
+  const hasBuildScript = existsSync(buildShPath)
+  const buildResult = hasBuildScript
+    ? await runBuild(buildShPath, cwd)
+    : { success: true, duration_ms: 0 }
+
+  if (hasBuildScript) {
+    process.stderr.write("Build...")
+    process.stderr.write(` ${buildResult.success ? "OK" : "FAIL"} (${buildResult.duration_ms}ms)\n`)
+  }
+
+  if (!buildResult.success) {
+    const output: ValidationOutput = {
+      success: false,
+      total_runs: 0,
+      valid_runs: 0,
+      failed_runs: [],
+      validation_errors: [],
+      metric: null,
+      quality_gates: {},
+      secondary_metrics: {},
+      assessment: null,
+      recommendations: null,
+      avg_duration_ms: 0,
+      build: {
+        ran: true,
+        success: false,
+        duration_ms: buildResult.duration_ms,
+        error: buildResult.error,
+      },
+    }
+    console.log(JSON.stringify(output, null, 2))
+    return
+  }
+
+  // 1. Warmup run — excluded from stats
+  process.stderr.write("Warmup run...")
+  const warmup = await runMeasurement(measureShPath, 0, cwd)
+  process.stderr.write(` ${warmup.success ? "OK" : "FAIL"} (${warmup.duration_ms}ms)\n`)
+
+  // 2. Run measure.sh N times sequentially
+  const results: RunResult[] = []
+  for (let i = 0; i < numRuns; i++) {
+    process.stderr.write(`Run ${i + 1}/${numRuns}...`)
+    const result = await runMeasurement(measureShPath, i + 1, cwd)
+    process.stderr.write(` ${result.success ? "OK" : "FAIL"} (${result.duration_ms}ms)\n`)
+    results.push(result)
+  }
+
+  // 3. Separate successful and failed runs
+  const successfulRuns = results.filter((r) => r.success && r.output)
+  const failedRuns = results
+    .filter((r) => !r.success)
+    .map((r) => ({ run: r.run, error: r.error! }))
+
+  // 4. Validate outputs against config
+  const validationErrors: Array<{ run: number; errors: string[] }> = []
+  const validOutputs: Array<{ run: number; output: Record<string, unknown> }> = []
+  for (const r of successfulRuns) {
+    const validation = validateOutput(r.output!, config)
+    if (validation.valid) {
+      validOutputs.push({ run: r.run, output: r.output! })
+    } else {
+      validationErrors.push({ run: r.run, errors: validation.errors })
+    }
+  }
+
+  // 5. Compute stats if we have enough valid runs (>= 2)
+  let metric: FieldStats | null = null
+  let assessment: Assessment | null = null
+  let recommendations: { noise_threshold: number; repeats: number } | null = null
+
+  function computeFieldStats(fields: string[]): Record<string, FieldStats> {
+    const stats: Record<string, FieldStats> = {}
+    for (const field of fields) {
+      const values = validOutputs
+        .map((r) => r.output[field])
+        .filter((v): v is number => typeof v === "number" && isFinite(v))
+      if (values.length >= 2) {
+        stats[field] = computeStats(field, values)
+      }
+    }
+    return stats
+  }
+
+  let qualityGateStats: Record<string, FieldStats> = {}
+  let secondaryMetricStats: Record<string, FieldStats> = {}
+
+  if (validOutputs.length >= 2) {
+    const metricValues = validOutputs.map((r) => r.output[config.metric_field] as number)
+    metric = computeStats(config.metric_field, metricValues)
+    assessment = assess(metric.cv_percent)
+    const rec = recommend(metric.cv_percent)
+    recommendations = rec.noise_threshold >= 0 ? rec : null
+
+    qualityGateStats = computeFieldStats(Object.keys(config.quality_gates))
+    secondaryMetricStats = computeFieldStats(Object.keys(config.secondary_metrics ?? {}))
+  }
+
+  // 6. Output result
+  const avgDuration =
+    results.length > 0
+      ? Math.round(results.reduce((sum, r) => sum + r.duration_ms, 0) / results.length)
+      : 0
+
+  const output: ValidationOutput = {
+    success: failedRuns.length === 0 && validationErrors.length === 0 && validOutputs.length >= 2,
+    total_runs: numRuns,
+    valid_runs: validOutputs.length,
+    failed_runs: failedRuns,
+    validation_errors: validationErrors,
+    metric,
+    quality_gates: qualityGateStats,
+    secondary_metrics: secondaryMetricStats,
+    assessment,
+    recommendations,
+    avg_duration_ms: avgDuration,
+    build: {
+      ran: hasBuildScript,
+      success: true,
+      duration_ms: buildResult.duration_ms,
+    },
+  }
+
+  console.log(JSON.stringify(output, null, 2))
+}
+
+main().catch((err) => {
+  console.log(JSON.stringify({ success: false, error: String(err) }))
+})

package/src/lib/worktree.ts

@@ -0,0 +1,40 @@
+import { $ } from "bun"
+import { join } from "node:path"
+import { mkdir } from "node:fs/promises"
+import { formatShellError } from "./git.ts"
+
+/**
+ * Creates a git worktree for a run. The worktree is created inside
+ * .autoauto/worktrees/<runId>/ and checks out a new experiment branch.
+ *
+ * Returns the absolute worktree path.
+ */
+export async function createWorktree(
+  mainRoot: string,
+  runId: string,
+  programSlug: string,
+): Promise<string> {
+  const worktreesDir = join(mainRoot, ".autoauto", "worktrees")
+  await mkdir(worktreesDir, { recursive: true })
+
+  const worktreePath = join(worktreesDir, runId)
+  const branchName = `autoauto-${programSlug}-${runId}`
+
+  try {
+    await $`git worktree add -b ${branchName} ${worktreePath}`.cwd(mainRoot).quiet()
+  } catch (err) {
+    throw new Error(formatShellError(err, `git worktree add (branch ${branchName})`), { cause: err })
+  }
+
+  return worktreePath
+}
+
+/**
+ * Removes a git worktree. Safe to call if the worktree doesn't exist.
+ */
+export async function removeWorktree(
+  mainRoot: string,
+  worktreePath: string,
+): Promise<void> {
+  await $`git worktree remove --force ${worktreePath}`.cwd(mainRoot).nothrow().quiet()
+}

package/src/screens/AuthErrorScreen.tsx

@@ -0,0 +1,31 @@
+export function AuthErrorScreen({ error }: { error: string }) {
+  return (
+    <box
+      flexDirection="column"
+      flexGrow={1}
+      border
+      borderStyle="rounded"
+      title="AutoAuto"
+      justifyContent="center"
+      alignItems="center"
+    >
+      <text>
+        <span fg="#ff5555"><strong>Authentication required</strong></span>
+      </text>
+      <box height={1} />
+      <text>AutoAuto needs access to the Anthropic API to run.</text>
+      <box height={1} />
+      <text>Run one of:</text>
+      <text fg="#7aa2f7">{"  claude login         (recommended)"}</text>
+      <text fg="#7aa2f7">{"  claude setup-token   (API key)"}</text>
+      <box height={1} />
+      <text>Then restart AutoAuto.</text>
+      {error && (
+        <>
+          <box height={1} />
+          <text fg="#888888" selectable>Error: {error}</text>
+        </>
+      )}
+    </box>
+  )
+}