atelier

README

Dragon Atelier

Mission Control for AI-assisted development. A keyboard-driven terminal cockpit for everyone juggling multiple projects across Claude Code — written in Go with Bubble Tea.

---

Why

If you run AI-assisted workflows all day, your projects, your Claude sessions, your memory store and your costs live in a dozen different places. Dragon Atelier pulls them into a single terminal dashboard you drive entirely from the keyboard — no mouse, no browser tabs, no context-switching.

It's the cockpit I use every day to jump between repos, watch live agent sessions, and keep an eye on what they cost.

Features

Everything below is built and working today — not a roadmap.

📚 Project registry ("Tomos")

Register every project once and launch it instantly. The list shows a live git status indicator per repo (clean / modified / untracked) and supports fuzzy / search.

Per-project actions:

• Launch any AI coding agent — Claude Code, Codex, Gemini and more, each in the project directory. The launcher list is configurable (see Configuration); uninstalled CLIs are marked (no instalado).
• Open in VS Code
• Open a PowerShell rooted at the project
• Copy the path to the clipboard
• Jump straight into the project's memory, history, or disk views
• Link the project to its Engram memory — pick the real Engram project key from a list (with observation counts) so "Ver memoria" shows the right data even when the folder name and the Engram key differ

🛰️ Agent Monitor — the war room

A live tile grid of your active Claude Code sessions, refreshed by a filesystem watcher:

• Real-time USD cost telemetry per session, computed from token usage
• Sub-agent grouping — expand/collapse the agents a session spawned
• Zoom into any tile for detail, and step-by-step replay of a session's events with pause and variable playback speed

🧠 Engram memory browser

Browse and fuzzy-search the persistent AI memory (Engram) for the selected project, then open any observation in a scrollable detail pane. Reads the local Engram SQLite store directly.

🕓 Unified project history

A single timeline that merges git commits and SDD (Spec-Driven Development) archives for a project, newest first. Drill into any entry to see the full git show diff or the archived change document.

💾 Disk usage

A breakdown of what your AI tooling is costing you on disk: the Engram database, the total ~/.claude/projects footprint, and a per-project tally. Hit Enter on any row to open it in your file explorer.

🎵 Now playing & live audio visualizer

An ambient card on the welcome screen showing the track currently playing on your system — title, artist and source — read from the Windows System Media Transport Controls (the same source that powers the OS media flyout), so Spotify and browser audio are reported uniformly. Beside it, a real-time waveform driven by WASAPI loopback capture + FFT: the bars react to the actual sound coming out of your speakers, in dragon colours. Pure Go, no CGO.

🐉 Crafted, degradation-aware UI

Catppuccin Mocha palette with custom dragon-brand accents, and a graceful text-only fallback when the terminal is too small for the full art.

Keybindings

Screen	Keys
Welcome	Enter projects · a agent monitor · l launcher manager · q quit
Launcher manager	j/k navigate · a add · e edit · d delete · J/K reorder · esc back
Projects	↑/↓ j/k navigate · / search · Enter actions · n new · d delete · r refresh git status · m monitor · esc back
Project actions	j/k navigate · Enter run · esc back
Agent monitor	j/k navigate · 1–9 jump · o/c expand/collapse sub-agents · Enter zoom · esc back
Agent zoom	r replay · esc back
Replay	space pause/resume · +/- speed · >/< step · esc back
Memory / History	j/k navigate · / filter · Enter open detail · esc back
Memory link (Engram)	j/k navigate · Enter link the chosen key · esc back
Disk usage	j/k navigate · Enter open in explorer · esc back

Ctrl+C quits from anywhere.

Architecture

A deliberately simple, testable design:

• Single Model, value semantics. All application state lives in one struct; every Update branch returns a new Model (immutable updates), which keeps state transitions easy to reason about and to test.
• Screen state machine. A Screen enum drives Update and View; each screen has its own key handler and renderer.
• Dependency injection at the boundary. Registry, launchers, clipboard, the transcript scanner/watcher, the Engram client and git readers are all interfaces injected in main, with fakes in tests — the TUI never touches the OS directly.
• Nil-safe degradation. A missing Engram DB or absent git doesn't crash the app; the relevant screen surfaces a friendly message instead.

cmd/atelier/         entry point + dependency wiring
internal/
  tui/               Bubble Tea model, update, view, per-screen key handlers
  registry/          project store (the "Tomos")
  actions/           launchers: Claude Code, VS Code, PowerShell, clipboard
  transcripts/       Claude session parser, cost pricing, fs watcher, replay
  engram/            Engram SQLite client + observation types
  git/               status / log / show readers
  disk/              usage walker + explorer integration
  nowplaying/        SMTC now-playing provider (Windows) + parsing
  audio/             WASAPI loopback capture + FFT spectrum analysis
  config/            atelier + app config

Test coverage spans unit tests, mocked-dependency tests, and golden snapshot tests of the rendered TUI.

Configuration

Manage launchers without leaving the TUI. Press l on the welcome screen to open the launcher manager — add, edit, delete and reorder agent launchers right there. Changes are saved to ~/.atelier/config.yaml for you, so you never have to find or hand-edit a config file. The YAML below is just what it writes.

Dragon Atelier reads optional settings from ~/.atelier/config.yaml. The file is entirely optional — every key falls back to a sensible default.

# How recent (minutes) a session's last activity must be to count as "active".
active_window_minutes: 15
# Fallback polling interval (ms) for the agent monitor.
polling_interval_ms: 500

# Agent launchers shown at the top of the per-project actions menu. Each entry is
# spawned, detached, in the project directory. Omit this key to keep the defaults
# (Claude Code, Codex, Gemini); set it to fully customise; set it to [] to clear.
launchers:
  - { label: "Claude Code", command: "claude" }
  - { label: "Codex",       command: "codex" }
  - { label: "Gemini",      command: "gemini" }
  - { label: "Aider",       command: "aider", args: ["--no-auto-commits"] }

command is resolved on your PATH; args (optional) are passed verbatim after it, so CLIs that need a subcommand or flag just work. Adding a new tool is a YAML edit — no rebuild.

Install

Never installed anything like this? Paste this into any AI chat

You do not need to know what a terminal is. Open whatever AI assistant you already use — ChatGPT in a browser, Claude, Codex, anything — and paste the block below. It carries the exact steps, so the assistant walks you through them instead of guessing.

Necesito ayuda para instalar un programa llamado Dragon Atelier en mi Windows.
No sé de programación, así que explicame cada paso de forma simple y esperá mi
respuesta antes de seguir al siguiente. Si podés ejecutar comandos en mi
computadora, hacelo vos. Si no podés, dictame qué hacer y ayudame si algo falla.

Estos son los pasos exactos. No busques otros ni cambies las direcciones:

1. Abrir esta página: https://github.com/GastonZ/Atelier/releases/latest
2. Descargar el archivo llamado: dragon_atelier-windows-amd64.exe
3. Crear una carpeta en Documentos llamada "Dragon Atelier" y mover el archivo ahí.
4. Hacer doble clic en el archivo.

IMPORTANTE — avisame de esto ANTES de que descargue:
Windows va a mostrar una pantalla azul que dice "Windows protegió su PC".
Aparece porque el programa no está firmado digitalmente, o sea que Windows no
puede confirmar quién lo publicó. No significa que sea peligroso. Para continuar
hay que hacer clic en "Más información" y después en "Ejecutar de todas formas".

Si en cambio Windows lo bloquea y no aparece ninguna opción para continuar,
significa que tiene activado "Control de aplicaciones inteligente". En ese caso
avisame que pare y que le pida ayuda a la persona que me pasó el programa. No me
digas cómo desactivar esa protección.

Cuando el programa abra, va a mostrar una pantalla con un dragón y la opción
"Empezá acá - instalar todo". Ahí termina tu trabajo: el resto lo hace el
programa solo.

Download (recommended)

Grab the latest prebuilt binary from the Releases page — no Go toolchain required:

1. Download dragon_atelier-windows-amd64.exe (Windows). Linux/macOS builds are attached too.
2. Double-click it, or run it from a terminal.

That's it. On first launch the project registry is empty — press n to add your projects.

Prerequisites for the full experience: the launchers and agent monitor expect Claude Code installed and ~/.claude/projects present. Without it the app still runs; those panels just show empty. The Engram memory browser is optional too (nil-safe when ~/.engram is absent).

Build from source

Prerequisites: Go 1.25+ and (optionally) the Task runner.

git clone https://github.com/GastonZ/Atelier.git
cd Atelier
task build          # or: go build -o dragon_atelier ./cmd/atelier

Run

./dragon_atelier           # Linux / macOS
./dragon_atelier.exe       # Windows

dragon_atelier version     # print version and exit
dragon_atelier help        # usage

Terminals smaller than ~100×48 show a text-only fallback. Resize for the full dragon.

Status

Active personal project, used daily. The .goreleaser.yaml is provisional and will be validated before the first v0.1.0 tag.

License

MIT — Copyright 2026 Gaston Zappulla