@spacek33z/autoauto 0.0.1

package/src/lib/run.ts

@@ -0,0 +1,383 @@
+import { rename, readdir, appendFile, rm } from "node:fs/promises"
+import { join } from "node:path"
+import { $ } from "bun"
+import { getProgramDir, type ProgramConfig } from "./programs.ts"
+
+// --- Types ---
+
+/** Status values for results.tsv rows */
+export type ExperimentStatus = "keep" | "discard" | "measurement_failure" | "crash"
+
+/** Phases the daemon/orchestrator can be in */
+export type RunPhase =
+  | "idle"
+  | "baseline"
+  | "agent_running"
+  | "measuring"
+  | "reverting"
+  | "kept"
+  | "stopping"
+  | "complete"
+  | "crashed"
+  | "finalizing"
+
+/** Termination reason for a completed run */
+export type TerminationReason = "aborted" | "max_experiments" | "stopped" | "stagnation"
+
+/** Persisted run state — the checkpoint file */
+export interface RunState {
+  run_id: string
+  program_slug: string
+  phase: RunPhase
+  experiment_number: number
+  original_baseline: number
+  current_baseline: number
+  best_metric: number
+  best_experiment: number
+  total_keeps: number
+  total_discards: number
+  total_crashes: number
+  branch_name: string
+  original_baseline_sha: string
+  last_known_good_sha: string
+  candidate_sha: string | null
+  started_at: string
+  updated_at: string
+  /** Agent provider used for this run. Legacy runs omit this and default to Claude. */
+  provider?: string
+  /** Model alias/ID used for this run (e.g. "sonnet" or "anthropic/claude-sonnet-4-5") */
+  model?: string
+  /** Effort level used for this run */
+  effort?: string
+  /** Cumulative input+output tokens across all experiments */
+  total_tokens?: number
+  /** Cumulative cost in USD across all experiments */
+  total_cost_usd?: number
+  /** Why the run terminated (set on completion) */
+  termination_reason?: TerminationReason | null
+  /** Branch the user was on before the run started */
+  original_branch?: string
+  /** Absolute path to the AutoAuto-owned worktree */
+  worktree_path?: string
+  /** True when running without worktree isolation (experiments run in main checkout) */
+  in_place?: boolean
+  /** Error message if the run crashed */
+  error?: string | null
+  /** Which phase the error occurred in */
+  error_phase?: RunPhase | null
+}
+
+/** A single row in results.tsv */
+export interface ExperimentResult {
+  experiment_number: number
+  commit: string
+  metric_value: number
+  secondary_values: string
+  status: ExperimentStatus
+  description: string
+  /** Total wall time for the measurement series (all repeats), in ms */
+  measurement_duration_ms: number
+  /** Diff stats JSON — e.g. {"lines_added":12,"lines_removed":5}. Absent for old runs. */
+  diff_stats?: string
+}
+
+/** Structured secondary values stored in results.tsv */
+export interface SecondaryValuesBlob {
+  quality_gates: Record<string, number>
+  secondary_metrics: Record<string, number>
+}
+
+/** Serializes DiffStats into compact JSON for results.tsv. */
+export function serializeDiffStats(stats: { lines_added: number; lines_removed: number } | undefined): string {
+  if (!stats) return ""
+  return JSON.stringify({ lines_added: stats.lines_added, lines_removed: stats.lines_removed })
+}
+
+/** Serializes quality gate and secondary metric medians into the structured JSON format. */
+export function serializeSecondaryValues(
+  qualityGates: Record<string, number>,
+  secondaryMetrics: Record<string, number>,
+): string {
+  return JSON.stringify({ quality_gates: qualityGates, secondary_metrics: secondaryMetrics })
+}
+
+/**
+ * Parses secondary_values JSON with backward compatibility.
+ * New format: { quality_gates: {...}, secondary_metrics: {...} }
+ * Old format: flat { field: value, ... } — all values placed under quality_gates.
+ */
+export function parseSecondaryValues(raw: string | undefined): SecondaryValuesBlob {
+  const empty: SecondaryValuesBlob = { quality_gates: {}, secondary_metrics: {} }
+  if (!raw) return empty
+  try {
+    const parsed = JSON.parse(raw)
+    if (typeof parsed !== "object" || parsed === null) return empty
+    // Detect new structured format
+    if ("quality_gates" in parsed || "secondary_metrics" in parsed) {
+      return {
+        quality_gates: (parsed as Record<string, unknown>).quality_gates as Record<string, number> ?? {},
+        secondary_metrics: (parsed as Record<string, unknown>).secondary_metrics as Record<string, number> ?? {},
+      }
+    }
+    // Old flat format — treat all values as quality gates
+    return { quality_gates: parsed as Record<string, number>, secondary_metrics: {} }
+  } catch {
+    return empty
+  }
+}
+
+// --- Run ID ---
+
+const pad = (n: number) => String(n).padStart(2, "0")
+
+export function generateRunId(): string {
+  const now = new Date()
+  return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`
+}
+
+// --- State Persistence ---
+
+/** Atomically writes state.json via temp-file + rename. */
+export async function writeState(runDir: string, state: RunState): Promise<void> {
+  const tmpPath = join(runDir, "state.json.tmp")
+  await Bun.write(tmpPath, JSON.stringify(state, null, 2) + "\n")
+  await rename(tmpPath, join(runDir, "state.json"))
+}
+
+export async function readState(runDir: string): Promise<RunState> {
+  return Bun.file(join(runDir, "state.json")).json() as Promise<RunState>
+}
+
+// --- Results ---
+
+export async function appendResult(runDir: string, result: ExperimentResult): Promise<void> {
+  const secondaryStr = result.secondary_values || ""
+  const diffStatsStr = result.diff_stats || ""
+  const line = `${result.experiment_number}\t${result.commit}\t${result.metric_value}\t${secondaryStr}\t${result.status}\t${result.description}\t${result.measurement_duration_ms}\t${diffStatsStr}\n`
+  await appendFile(join(runDir, "results.tsv"), line)
+}
+
+// --- Results Parsing (synchronous — operate on pre-read content) ---
+
+/** Parses a single TSV row into a typed result. Returns null if malformed. */
+function parseTsvRow(line: string): ExperimentResult | null {
+  const parts = line.split("\t")
+  if (parts.length < 6) return null
+  return {
+    experiment_number: parseInt(parts[0], 10),
+    commit: parts[1],
+    metric_value: parseFloat(parts[2]),
+    secondary_values: parts[3],
+    status: parts[4] as ExperimentStatus,
+    description: parts[5],
+    measurement_duration_ms: parts[6] ? parseInt(parts[6], 10) : 0,
+    diff_stats: parts[7] || undefined,
+  }
+}
+
+/** Formats header + last N data rows from raw results.tsv content. */
+export function formatRecentResults(raw: string, count = 15): string {
+  const lines = raw.split("\n").filter(Boolean)
+  if (lines.length <= 1) return lines.join("\n")
+
+  const header = lines[0]
+  const rows = lines.slice(1)
+  const recent = rows.slice(-count)
+  return [header, ...recent].join("\n")
+}
+
+/** Parses the last row of raw results.tsv content into a typed object. */
+export function parseLastResult(raw: string): ExperimentResult | null {
+  const lines = raw.trim().split("\n")
+  if (lines.length <= 1) return null // only header
+  return parseTsvRow(lines[lines.length - 1])
+}
+
+/** Parses the last keep row from raw results.tsv content. */
+export function parseLastKeepResult(raw: string): ExperimentResult | null {
+  const lines = raw.trim().split("\n")
+  for (let i = lines.length - 1; i >= 1; i--) {
+    const row = parseTsvRow(lines[i])
+    if (row?.status === "keep") return row
+  }
+  return null
+}
+
+/** Extracts SHAs of recent discarded/crashed experiments from raw results.tsv content. */
+export function parseDiscardedShas(raw: string, count = 5): string[] {
+  const lines = raw.trim().split("\n")
+  const shas: string[] = []
+
+  for (let i = lines.length - 1; i >= 1 && shas.length < count; i--) {
+    const parts = lines[i].split("\t")
+    if (parts.length >= 5) {
+      const status = parts[4]
+      if (status === "discard" || status === "crash" || status === "measurement_failure") {
+        shas.push(parts[1]) // commit SHA
+      }
+    }
+  }
+
+  return shas
+}
+
+// --- Results Reading ---
+
+/** Parses the entire results.tsv into a typed array. */
+export async function readAllResults(runDir: string): Promise<ExperimentResult[]> {
+  const raw = await Bun.file(join(runDir, "results.tsv")).text()
+  const lines = raw.trim().split("\n")
+  if (lines.length <= 1) return [] // only header
+
+  const results: ExperimentResult[] = []
+  for (let i = 1; i < lines.length; i++) {
+    const row = parseTsvRow(lines[i])
+    if (row) results.push(row)
+  }
+  return results
+}
+
+/** Extracts metric values from keep results for sparkline/chart rendering. */
+export function getMetricHistory(results: ExperimentResult[]): number[] {
+  return results
+    .filter((r) => r.status === "keep")
+    .map((r) => r.metric_value)
+}
+
+/** Computes average measurement duration from results that have duration data. */
+export function getAvgMeasurementDuration(results: ExperimentResult[]): number | null {
+  const durations = results
+    .filter((r) => r.measurement_duration_ms > 0)
+    .map((r) => r.measurement_duration_ms)
+  if (durations.length === 0) return null
+  return Math.round(durations.reduce((sum, d) => sum + d, 0) / durations.length)
+}
+
+/** Derived statistics from state for the TUI dashboard. */
+export interface RunStats {
+  total_experiments: number
+  total_keeps: number
+  total_discards: number
+  total_crashes: number
+  keep_rate: number
+  improvement_pct: number
+  current_improvement_pct: number
+}
+
+function computeImprovementPct(
+  original: number,
+  current: number,
+  direction: ProgramConfig["direction"],
+): number {
+  if (original === 0) return 0
+  return direction === "lower"
+    ? ((original - current) / Math.abs(original)) * 100
+    : ((current - original) / Math.abs(original)) * 100
+}
+
+/** Computes derived statistics from run state. Counts come from RunState's authoritative counters. */
+export function getRunStats(state: RunState, direction: ProgramConfig["direction"]): RunStats {
+  const total = state.total_keeps + state.total_discards + state.total_crashes
+
+  return {
+    total_experiments: total,
+    total_keeps: state.total_keeps,
+    total_discards: state.total_discards,
+    total_crashes: state.total_crashes,
+    keep_rate: total > 0 ? state.total_keeps / total : 0,
+    improvement_pct: computeImprovementPct(state.original_baseline, state.best_metric, direction),
+    current_improvement_pct: computeImprovementPct(state.original_baseline, state.current_baseline, direction),
+  }
+}
+
+// --- Run Listing ---
+
+/** Metadata for a run, used in list views. */
+export interface RunInfo {
+  run_id: string
+  run_dir: string
+  state: RunState | null
+}
+
+/** Lists all runs for a program, sorted newest first. */
+export async function listRuns(programDir: string): Promise<RunInfo[]> {
+  const runsDir = join(programDir, "runs")
+  let entries: string[]
+  try {
+    const dirents = await readdir(runsDir, { withFileTypes: true })
+    entries = dirents.filter((e) => e.isDirectory()).map((e) => e.name)
+  } catch {
+    return []
+  }
+
+  const runs = await Promise.all(
+    entries.map(async (runId): Promise<RunInfo> => {
+      const runDir = join(runsDir, runId)
+      let state: RunState | null = null
+      try {
+        state = await readState(runDir)
+      } catch {
+        // state.json missing or corrupt
+      }
+      return { run_id: runId, run_dir: runDir, state }
+    }),
+  )
+
+  runs.sort((a, b) => b.run_id.localeCompare(a.run_id))
+  return runs
+}
+
+/** Returns the most recent run for a program. */
+export async function getLatestRun(programDir: string): Promise<RunInfo | null> {
+  const runs = await listRuns(programDir)
+  return runs.length > 0 ? runs[0] : null
+}
+
+export function isRunActive(r: RunInfo): boolean {
+  const phase = r.state?.phase
+  return phase != null && phase !== "complete" && phase !== "crashed"
+}
+
+// --- Run Deletion ---
+
+/** Deletes a completed/crashed run: removes run directory, worktree, and git branch. */
+export async function deleteRun(projectRoot: string, run: RunInfo): Promise<void> {
+  if (isRunActive(run)) {
+    throw new Error("Cannot delete an active run")
+  }
+
+  const state = run.state
+
+  // Remove worktree if it exists (skip for in-place runs — there's no worktree)
+  if (state?.worktree_path && !state?.in_place) {
+    await $`git worktree remove --force ${state.worktree_path}`.cwd(projectRoot).nothrow().quiet()
+  }
+
+  // Delete the experiment branch
+  if (state?.branch_name) {
+    await $`git branch -D ${state.branch_name}`.cwd(projectRoot).nothrow().quiet()
+  }
+
+  // Remove the run directory
+  await rm(run.run_dir, { recursive: true, force: true })
+}
+
+/** Deletes an entire program: removes all runs (worktrees + branches) and the program directory. */
+export async function deleteProgram(projectRoot: string, slug: string): Promise<void> {
+  const programDir = getProgramDir(projectRoot, slug)
+  const runs = await listRuns(programDir)
+
+  const activeRun = runs.find(isRunActive)
+  if (activeRun) {
+    throw new Error("Cannot delete a program with an active run")
+  }
+
+  // Delete all runs first (cleans up worktrees + branches)
+  for (const run of runs) {
+    await deleteRun(projectRoot, run)
+  }
+
+  // Remove the program directory
+  await rm(programDir, { recursive: true, force: true })
+}
+

package/src/lib/syntax-theme.ts

@@ -0,0 +1,39 @@
+import { SyntaxStyle } from "@opentui/core"
+import type { ThemeTokenStyle } from "@opentui/core"
+
+const theme: ThemeTokenStyle[] = [
+  // Base text
+  { scope: ["default"], style: { foreground: "#a9b1d6" } },
+
+  // Keywords & control flow
+  { scope: ["keyword"], style: { foreground: "#bb9af7", bold: true } },
+  { scope: ["operator"], style: { foreground: "#89ddff" } },
+
+  // Literals
+  { scope: ["string"], style: { foreground: "#9ece6a" } },
+  { scope: ["number"], style: { foreground: "#ff9e64" } },
+  { scope: ["constant"], style: { foreground: "#ff9e64" } },
+
+  // Functions & types
+  { scope: ["function"], style: { foreground: "#7aa2f7" } },
+  { scope: ["type"], style: { foreground: "#2ac3de" } },
+
+  // Comments
+  { scope: ["comment"], style: { foreground: "#565f89", italic: true } },
+
+  // Variables & properties
+  { scope: ["variable"], style: { foreground: "#c0caf5" } },
+  { scope: ["property"], style: { foreground: "#73daca" } },
+  { scope: ["punctuation"], style: { foreground: "#89ddff" } },
+  { scope: ["tag"], style: { foreground: "#f7768e" } },
+
+  // Markdown-specific
+  { scope: ["markup.heading"], style: { foreground: "#7aa2f7", bold: true } },
+  { scope: ["markup.italic"], style: { italic: true } },
+  { scope: ["markup.bold"], style: { bold: true } },
+  { scope: ["markup.link"], style: { foreground: "#7aa2f7", underline: true } },
+  { scope: ["markup.raw"], style: { foreground: "#9ece6a" } },
+  { scope: ["markup.list"], style: { foreground: "#ff7b72" } },
+]
+
+export const syntaxStyle = SyntaxStyle.fromTheme(theme)

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

@@ -0,0 +1,77 @@
+/** Returns the system prompt for the experiment agent. Wraps program.md with framing instructions. */
+export function getExperimentSystemPrompt(
+  programMd: string,
+  options: { ideasBacklogEnabled?: boolean } = {},
+): string {
+  const useIdeasBacklog = options.ideasBacklogEnabled !== false
+  const notesInstruction = useIdeasBacklog ? `
+### 6. Leave Experiment Notes
+At the end of your final response, include exactly one notes block for the orchestrator:
+
+<autoauto_notes>
+{"hypothesis":"one sentence describing what you tried and why it should affect the metric","why":"one sentence describing what happened or what failure mode to watch for","avoid":["specific approach to avoid repeating"],"next":["specific follow-up idea to try next"]}
+</autoauto_notes>
+
+Keep these notes factual and short. Do not edit any ideas backlog file yourself; the orchestrator persists these notes.
+` : ""
+  const exitSectionNumber = useIdeasBacklog ? "7" : "6"
+
+  return `You are an AutoAuto Experiment Agent — one experiment in an autonomous optimization loop. An external orchestrator handles measurement, keep/discard decisions, and loop control. Your job: analyze, plan ONE targeted optimization, implement it, validate it, and commit.
+
+${programMd}
+
+## How to Be a Good Experimenter
+
+### 1. Analyze Before Acting
+- Read the codebase within scope. Understand the current implementation before proposing changes.
+- Study results.tsv carefully: which approaches were kept? Which were discarded? What patterns emerge?
+- If "Measurement Diagnostics" are provided in the context, study them carefully — they contain detailed output from the measurement tool (e.g., which specific audits, tests, or checks are failing) that should guide your optimization choice. Do NOT guess from code inspection when diagnostics are available.
+- Review the 'Recently Discarded Experiments' section above to understand WHY past experiments failed — don't just note that they failed.
+- Identify the actual bottleneck or opportunity. A targeted change to the real bottleneck beats a shotgun approach.
+- If you're experiment #1, spend extra time reading the codebase. Later experiments should build on what the history tells you.
+
+### 2. Choose ONE Mechanism to Test
+- Pick ONE specific mechanism per experiment. "Replace regex with indexOf in URL extraction to avoid backtracking" is good. "Various improvements" is bad.
+- Build on what worked: if recent keeps share a pattern (e.g., reducing allocations), explore that direction further.
+- Avoid what failed: if recent discards share a pattern (e.g., algorithmic changes that broke quality), steer clear.
+- Do NOT repeat discarded approaches — even with minor variations. If tree shaking was discarded, "better tree shaking" is likely wasteful too.
+- You should be able to explain in one sentence WHY your change should improve the metric. If you can't, pick a different approach.
+- When the obvious optimizations are exhausted, look deeper: profile the code mentally, read the hot path line by line, check for redundant work, unnecessary allocations, or algorithmic inefficiency.
+
+### 3. Implement the Change
+- Make exactly ONE focused change — not multiple changes at once.
+- Keep diffs small and reviewable. A 10-line targeted fix beats a 200-line refactor.
+- Stay strictly within the allowed file scope defined in program.md.
+- NEVER modify files in .autoauto/ — these are locked by the orchestrator.
+- NEVER modify measure.sh, build.sh, or config.json — they are read-only (chmod 444).
+- NEVER hardcode absolute home directory paths (e.g. /Users/username/...). Use relative paths, \`$HOME\`, or \`~\`.
+
+### 4. Validate
+- Run existing tests if available. If tests fail, fix them or revert — do NOT commit broken code.
+- If your change breaks the build, try to fix it. If you can't fix it quickly, revert everything and exit without committing.
+- Do NOT run the measurement script — the orchestrator handles that after you commit.
+
+### 5. Commit with a Descriptive Message
+- Commit with: git add -A && git commit -m "<type>(scope): description"
+- Explain the MECHANISM in your commit message, not just the action:
+  - Good: "perf(parser): replace regex with indexOf for URL extraction — avoids backtracking on long strings"
+  - Bad: "perf: improve performance"
+- The commit message is how future experiment agents learn from your work. Make it count.
+${notesInstruction}
+### ${exitSectionNumber}. When to Exit Without Committing
+- If you've analyzed the code and can't find a promising change within scope — exit. A no-commit is better than a low-quality experiment that wastes measurement time.
+- If validation fails and you cannot fix it — revert and exit.
+- If your proposed change is essentially the same as a recently discarded experiment — exit instead of wasting a cycle.
+- Do NOT ask for human input — you are fully autonomous.
+
+## What Makes Experiments Fail (Avoid These)
+- **Repeating discarded ideas:** The #1 waste of cycles. Read the history carefully.
+- **Shotgun changes:** Multiple unrelated changes in one experiment. The orchestrator can't tell which one helped.
+- **Out-of-scope modifications:** Touching files outside your allowed scope gets the entire experiment discarded.
+- **Speculative changes without a mechanism:** "Maybe this will help" changes rarely work. Have a clear hypothesis.
+- **Over-engineering:** Adding complexity that doesn't directly serve the metric. Simpler is better at equal metric.
+- **Benchmark-specific tricks:** Bitwise hacks the compiler already does, unrolled loops for specific sizes — these don't generalize.
+
+## Simplification Bonus
+The orchestrator automatically keeps experiments that **remove more code than they add** (net negative lines changed) as long as the metric doesn't regress. You don't need to improve the metric to get a simplification kept — just don't make it worse. Look for dead code, redundant logic, unnecessary abstractions, or verbose patterns that can be tightened. Simplification keeps are valuable and count as real progress.`
+}

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

@@ -0,0 +1,90 @@
+/** Returns the system prompt for the finalize agent. Read-only review + grouping of accumulated experiment changes. */
+export function getFinalizeSystemPrompt(): string {
+  return `You are the AutoAuto Finalize Agent — a code reviewer for an autonomous experiment run. An orchestrator ran multiple experiments on a branch, keeping improvements and discarding failures. Your job: review the accumulated changes, assess risks, group them into logical changesets, and produce a structured summary.
+
+## Your Role
+
+You are a READ-ONLY reviewer. You MUST NOT modify any files. You only analyze and report.
+
+## Tools
+
+Use these tools to inspect the changes:
+- **Bash**: Run \`git log\`, \`git diff\`, \`git show <sha>\` to inspect individual commits and the overall diff
+- **Read**: Read source files to understand context around changes
+- **Glob/Grep**: Search the codebase to understand how changed code is used
+
+## Task
+
+1. Review the full diff provided in the user message
+2. Inspect individual experiment commits via \`git log --oneline\` and \`git show <sha>\` to understand the evolution
+3. Read surrounding source code to assess impact of changes
+4. Group the changed files into logical changesets (see Group Analysis below)
+5. Produce a structured summary (see Output Format below)
+
+## Group Analysis
+
+Your primary job is to group changed files into logical, independently-reviewable changesets. Each group will become its own git branch that can be reviewed and merged independently.
+
+**Rules:**
+- The user message includes a "Changed Files" list — this is the canonical set of files. Use ONLY files from this list.
+- Each file must appear in exactly ONE group. You cannot split changes within a single file across groups.
+- Group files that form a single logical change together (e.g., a feature + its tests, a refactor across related files).
+- Each group should be independently mergeable — it should make sense on its own without the other groups.
+- If all changes are tightly coupled and cannot be meaningfully separated, put everything in a single group. That's fine.
+- Use kebab-case for group names (e.g., "optimize-image-loading", "remove-unused-deps").
+
+## Output Format
+
+Your final output MUST contain all of these sections:
+
+## Summary
+One paragraph overview of what the experiment run accomplished. Mention the metric, improvement achieved, and number of kept changes.
+
+## Changes
+Bulleted list of each logical change. For each:
+- What was changed (file paths, function names)
+- Why it likely improved the metric
+- How significant the change is
+
+## Risk Assessment
+Flag any concerns:
+- **Security**: New attack surfaces, input validation gaps, auth changes
+- **User-facing behavior**: UI changes, API contract changes, output format changes
+- **Performance**: Potential regressions in non-measured dimensions (memory, startup time)
+- **Error handling**: Removed error checks, swallowed exceptions, narrowed error types
+- **Correctness**: Logic changes that might break edge cases
+
+If no risks are found, say "No significant risks identified."
+
+## Recommendations
+List items that warrant manual review before merging. If none, say "No specific recommendations."
+
+## Finalize Groups
+Wrap your grouping in XML tags containing a JSON array. Use conventional commit format for titles.
+
+<finalize_groups>
+[
+  {
+    "name": "optimize-image-loading",
+    "title": "perf(images): lazy-load below-fold images and use WebP format",
+    "description": "Converted eager image loading to intersection-observer-based lazy loading",
+    "files": ["src/components/ImageLoader.tsx", "src/utils/image.ts"],
+    "risk": "low"
+  },
+  {
+    "name": "remove-unused-deps",
+    "title": "refactor: remove lodash and moment.js dependencies",
+    "description": "Replaced lodash utilities with native array methods, moment with Intl.DateTimeFormat",
+    "files": ["package.json", "src/utils/date.ts", "src/utils/array.ts"],
+    "risk": "low"
+  }
+]
+</finalize_groups>
+
+Each group object must have:
+- \`name\`: kebab-case identifier (used in branch name)
+- \`title\`: conventional commit message for this group
+- \`description\`: 1-2 sentence summary of what changed
+- \`files\`: array of file paths (ONLY from the Changed Files list)
+- \`risk\`: "low", "medium", or "high"`
+}

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

@@ -0,0 +1,7 @@
+export { getSetupSystemPrompt, type SetupPromptResult } from "./setup.ts"
+export { getUpdateSystemPrompt, type UpdatePromptResult } from "./update.ts"
+export { getExperimentSystemPrompt } from "./experiment.ts"
+export { getFinalizeSystemPrompt } from "./finalize.ts"
+
+export const DEFAULT_SYSTEM_PROMPT =
+  "You are AutoAuto, an autoresearch assistant. Be concise."