Control Claude Code Without Losing the Thread

The Problem

You run Claude Code. You get 400 lines scrolling at machine speed. 90% is noise. The 10% that matters — a file touched out of scope, a missing translation, an unexpected behavior — disappears in the scroll.

Pragma fixes this.

How It Works

1. 1

   You write a prompt.

   Pragma injects the Pragma Protocol into Claude Code via --append-system-prompt. The session starts.

2. 2

   Claude works.

   Pragma reads the structured NDJSON stream line by line and atomizes every event: file touches, diffs, tool calls, errors, notes.

3. 3

   You navigate, not scroll.

   Atoms appear in a live feed — typed, color-coded, collapsible. The center panel tracks the current phase. You approve, confirm, or stop.

Pragma uses --output-format stream-json --verbose. Nothing is intercepted at the shell level — it’s Rust parsing a structured protocol.

Atom Types

Everything Claude does maps to one of these atom types. Each renders differently in the stream.

File type colors

FILE_TOUCH and DIFF use the file type color, not the atom type color.

Session Phases

Pragma doesn’t just stream atoms. It tracks where Claude is in the task and surfaces the right UI for each phase.

1. Idle Configure prompt, working directory, model, attachments.
2. Analyzing Claude processes the task. Analysis text builds in real time.
3. Awaiting Answers optional Claude has blocking questions. You answer or skip.
4. Awaiting Approval The plan (numbered steps) appears. Approve, modify, or switch to a stronger model — past five steps, Pragma proposes Opus and Fable.
5. Running Steps execute. Step progress visible. Stop anytime.
6. Awaiting Confirmation After each step: review, continue, or finalize early.
7. Complete Report + test checklist + closing. Export as JSON or Markdown.

Projects and Memory

A session is rarely the whole story. Symphony groups sessions into projects, and can hand what it learns to the rest of the ecosystem instead of leaving it in a scrollback buffer.

• Projects — every session belongs to one: title, working directory, colour, an optional Morphē reference. The session list, the full-text search, and export are scoped to the project you are in.
• Lexis memory — optional, off by default — point Pragma at a Lexis server and it asks for the context of earlier work before a run, then posts the finished session back when the run ends. Failed deliveries are retried from a queue. The server URL, the timeout, and a health check live in the Settings panel.
• Morphē handoffs — a handoff file left in the working directory is detected and offered to you as a ready-made prompt.

Lexis is the only thing Pragma sends over the network, and only once you enable it. Everything else stays in ~/.pragma/pragma.db on your machine. Plain HTTP is accepted only for loopback addresses.

What Else

• Model choice — Sonnet, Opus (Claude Opus 4.8), or Fable, chosen per session. The models key in ~/.pragma/settings.json maps each name in the interface to the id passed to Claude Code, so a newly released model can be adopted without waiting for a new build.
• Multi-profile CLI — Manage multiple Claude Code installations. Each profile has its own binary, config dir, and optional language override.
• Session history — Full-text search (SQLite FTS5) over past sessions. Load any session in read-only review mode.
• Attachments — Files copied to pragmadocs/ in the working dir. Claude sees them via --add-dir.
• Auto-confirm — Optional: step confirmations bypass automatically after 1.5s if no anomaly.
• Scroll lock — Stream auto-scrolls. Scroll up → lock activates → badge shows new atom count.
• Export — JSON or Markdown. From UI or CLI (pragma export <session-id>).
• Local-first — No telemetry, no cloud sync. Sessions in ~/.pragma/pragma.db. The Lexis integration is the one exception, and it stays off until you turn it on.
• Dark / Light theme — Persisted. Focus mode available.

Built On

Rust (Tauri v2) backend · Vue 3 + Pinia frontend · SQLite (WAL + FTS5) · NDJSON parser written in Rust.

Two Lines

Pragma started as an open-source project and grew into the app described on this page. Both lines share the same foundation — the protocol, the atoms, the phases — but only one of them is still moving.