orchard

An agent-aware, multi-repo terminal dashboard. See every local git repo on one screen (branch, dirty / ahead / behind, language, last commit) plus what your AI coding agents did across them: where Claude Code and Codex ran, the files they touched, and a flag when there is uncommitted AI work. Then pull, fetch, switch branches, search, diff, or open any repo in your editor, browser, or agent, all from the keyboard.

Install

Requirements

• Platforms: macOS and Linux (amd64/arm64). Windows is not supported yet.
• Runtime: git on your PATH.
• Build: Go 1.24+ only if you install from source or with go install.
• Optional:
  • A Nerd Font for the icons (any other monospace font works; icons just render as boxes).
  • gh (GitHub CLI) - used by orchard clone --org for auth if GITHUB_TOKEN isn't set.
  • claude and/or codex - for the agent keys (c, C, H, R, A, M); activity always shows from local history either way.
  • ast-grep - optional parser backend for Kotlin, TypeScript/TSX, Ruby, C#, Python, JavaScript, C, and C++; orchard can install a pinned copy with orchard graph install-ast-grep.
  • A supported terminal for new-tab launches: Ghostty, iTerm2, WezTerm, tmux, or macOS Terminal (otherwise it falls back to running in place).

Download a release (no Go required)

Grab the archive for your OS/arch from the Releases page, extract it, and move the orchard binary onto your PATH:

# e.g. macOS Apple Silicon - adjust the filename for your OS/arch
tar -xzf orchard_*_darwin_arm64.tar.gz
sudo mv orchard /usr/local/bin/
orchard version

On macOS the binary is unsigned, so the first launch may be blocked by Gatekeeper. Allow it once with:

xattr -d com.apple.quarantine /usr/local/bin/orchard    # or right-click → Open

go install (needs the Go toolchain)

go install github.com/prakashkurup/orchard@latest

From source

git clone https://github.com/prakashkurup/orchard.git
cd orchard
make build       # produces ./orchard (version stamped from git tags)
make install     # installs into ~/.local/bin (override with PREFIX=...)

Updating

orchard checks GitHub for a newer release at most once a day and shows a small notice when one is available (one anonymous request; opt out with ORCHARD_NO_UPDATE_CHECK=1).

orchard update     # download + checksum-verify + replace the binary in place

orchard update is for release-binary installs. If you installed with go install, run go install github.com/prakashkurup/orchard@latest instead (the command will tell you), and orchard update will say so for Homebrew/go-install builds rather than touching a managed binary.

Quick start

orchard                               # launch the TUI for the configured root
orchard --root ~/Documents/GitHub     # or point it at any folder
orchard preview                       # render one dashboard frame to stdout
orchard scan --root ~/code --json     # machine-readable status of every repo
orchard pull --root ~/code --all      # fast-forward every eligible repo
orchard graph build --repo ./api      # build a local code graph for an agent

orchard scans one root folder and treats each immediate subdirectory that contains a .git as a repository. (If the root itself is a repo, it shows just that one.)

The root defaults to your current directory, so cd ~/code && orchard just works. To make a root persistent, see Configuration.

Why orchard

Most tools either manage many repos or inspect AI assistant history. orchard combines both: an interactive multi-repo git dashboard that knows where you have been running Claude Code and Codex, launches either in any repo, and searches code across every repo at once.

If you know the space, gita, mani, gitpane, git-dash, and git-scope cover multi-repo git workflows; ccusage and claude-history cover Claude usage and history. orchard puts the local repo dashboard and the agent-aware workflow in the same window.

If you juggle many repositories and lean on Claude Code or Codex, orchard is the cockpit for that workflow. If you only ever work in one repo at a time, a single-repo TUI like lazygit will serve you better.

Features

• One-screen overview of every repo: branch, clean/dirty/ahead/behind/diverged/detached, uncommitted + stash counts, dominant language, last-synced and last-commit times (color-coded by freshness).
• Agent aware (Claude Code + Codex) - usage panel, a per-repo AGENT column marking each agent that ran, launch/resume/cross-repo sessions, and a flag for uncommitted AI work. See Claude Code & Codex below.
• Code graph for agents - build a SQLite symbol/call graph (B or orchard graph build) and serve it to Claude Code or Codex over MCP, including cross-repo sessions. See Code Graph & MCP.
• Safe bulk pull - fast-forward only; skips dirty repos, detached HEADs, and repos with no upstream (a non-fast-forward is reported, never forced).
• Fetch, branch switch, multi-select - act on one repo or many at once.
• Open anywhere - launch your editor (e), the repo in your browser (O), or your agent (c) in a new terminal tab; multi-repo actions ask for confirmation first.
• Cross-repo code search (S) that respects .gitignore.
• Preview docs (v) - render a repo's CLAUDE.md / AGENTS.md / README.md in the terminal, with its size and an estimated per-session token cost.
• GitHub aware - open PR count and CI status per repo (when a token is set), shown in the detail view, with a failing-CI flag on the dashboard.
• Worklog (L) - your own commits across all repos in a time window.
• Clone (+) a new repo into the dashboard, or orchard clone a scoped GitHub org.
• Scriptable CLI - scan, pull, clone with --json for cron and pipelines.

Claude Code & Codex

orchard treats AI coding agents as a first-class part of a multi-repo workflow, with the same treatment for Claude Code and OpenAI Codex. Everything is read locally from your ~/.claude transcripts (or $CLAUDE_CONFIG_DIR) and your ~/.codex session rollouts (or $CODEX_HOME); nothing is sent anywhere.

The action keys drive whichever assistant is resolved: $ORCHARD_AI_CMD if set, else the first of claude / codex on your PATH. The dashboard's AGENT column marks each agent that has run in a repo (both marks when you used both), and repos worked with both agents show both footprints side by side in the detail view.

See activity

• Usage panel pinned under the list: per-agent totals (sessions, turns, tokens, repos used, last active), a model split, and your busiest repos.
• Per-repo AGENT column: a mark for each agent that ran in the repo (both when you used both), with the freshest run age colored by recency.
• Active now: a session writing in the last ~60s shows live (green); if that repo is also dirty it shows !live (red), so live AI work on an uncommitted tree stands out.
• Per-repo footprint in the detail view (enter): each agent's recent sessions, turns, tokens, and last run, side by side when both have worked the repo.
• Files the agent touched (detail view): what it read or edited here, edited-first, with files it changed but hasn't committed flagged. Press f for the full list, then enter to open one in your editor or d to diff just that file.
• Uncommitted-work flag: when a repo is dirty and an agent ran there recently, the AGENT cell turns red with a !, so AI edits never get lost in an unstaged tree.
• Sort by agent (s): float the most recently agent-worked repos to the top.
• Stats (T / orchard stats): totals per agent, plus Claude and Codex activity heatmaps alongside the commit harvest.

Resume and search sessions

• Resume (C): continue the most recent session in the current repo (claude --continue / codex resume --last).
• Session history (H): browse a repo's past sessions by their titles (turn count, model, age) and resume any one (claude --resume <id> / codex resume <id>).
• Search past sessions (R): search the content of every repo's sessions at once and resume the match in its own repo. For deep semantic search and a full conversation viewer, the dedicated claude-history is excellent; orchard's R is a quick cross-repo find-and-resume without leaving the dashboard.

Launch across repos

• Launch (c): open the agent in a new terminal tab for the selected repo(s); multi-repo asks for confirmation.
• Across repos (A): one session spanning the selected repos, opened in the first with the rest attached via --add-dir, for cross-service work. space-select 2+ first. With Claude Code, each added repo's CLAUDE.md is loaded too (orchard sets CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1; opt out with ORCHARD_ADDDIR_MEMORY=0), so the session has the instructions for every repo, not just file access.
• Workspace presets (W): save a space-selected repo set under a name, then launch the cross-repo A session on it in one keystroke, for the groups of services you keep working on together. Stored in presets.json (see Files orchard writes).

Draft commit messages

• Draft a commit message (M): the agent drafts a message from the working-tree diff headlessly (claude -p, or codex exec in a read-only sandbox) and shows it in a window you can copy (y) or regenerate (r), without leaving the dashboard. Other assistants fall back to a terminal session.

Keep instructions healthy

• Instructions health (detail view + the needs-md filter): shows which repos have a CLAUDE.md / AGENTS.md, and flags repos where Claude runs with no project context, either no CLAUDE.md at all, or an AGENTS.md Claude won't read (Claude Code doesn't load AGENTS.md natively). I wires the latter up by creating a CLAUDE.md that imports @AGENTS.md (only where there's no CLAUDE.md yet; it never edits an existing one).

Codex parity

When Codex is the resolved assistant, the same keys drive it: C resumes the last session (codex resume --last), H browses and resumes past sessions, R searches session content, f lists the files it edited, A spans repos via --add-dir, and M drafts a commit message headlessly (codex exec in a read-only sandbox). Codex activity always shows regardless of which assistant launches: the AGENT column, the usage panel, the detail footprint, and the stats heatmaps read both agents' local history.

Panel or AGENT column empty?

The usage panel and AGENT column reflect repos you have actually run an agent in (as the working directory), not just that one is installed. If they look empty:

• Use an agent in a repo first. Run claude or codex inside one of the repos once; the panel and column fill from past sessions, not from installation.
• Point orchard at the right root. They only cover repos under orchard's root, so set --root / ORCHARD_ROOT to where you actually work.
• Relocated config? orchard reads ~/.claude (or $CLAUDE_CONFIG_DIR) and ~/.codex (or $CODEX_HOME).
• The c launcher is missing? orchard needs claude or codex on your PATH (a shell alias or function does not count) or ORCHARD_AI_CMD=/full/path/to/the/binary. GUI launches often have a thinner PATH than your terminal.

Code Graph & MCP

orchard can build a local code graph for a repo: files, symbols, signatures, call edges, PageRank importance, and freshness metadata stored in SQLite. Claude Code and Codex can query that graph over MCP instead of burning context on broad greps and whole-file reads.

The graph is intentionally local and read-only. Responses include signatures and file/line locations, not function bodies. Go uses the standard library parser for precise results; non-Go languages use ast-grep when available, with quality tiers surfaced as precise, good, or best-effort so you know when the graph is a guide versus when to open the file.

Useful commands:

• orchard graph install-ast-grep downloads orchard's pinned, checksum-verified ast-grep binary into the orchard config dir.
• orchard graph build --repo PATH builds or refreshes a repo graph.
• orchard graph status --repo PATH shows freshness, size, stale state, and parser-quality tiers.
• orchard graph map|find|callers|blast|search --repo PATH NAME queries the graph from the CLI.
• orchard mcp --repo A --repo B serves one merged MCP view across multiple repos. Startup indexing runs in the background; the MCP status tool reports indexing and any last error.

In the TUI, B builds selected repo graphs, D deletes graph caches, and m toggles automatic MCP wiring for launches. The GR column shows ● fresh, ◐ stale, or blank when no useful graph exists. When wiring is enabled, launching Claude Code or Codex merges an orchard MCP server into the project config for the repo set you are launching.

TUI keys

Press ? in-app for the same keymap and legend.

Navigate and select

Key	Action
↑ ↓ / j k	move · g / G top / bottom
mouse	click a row to select, wheel to scroll (disable with ORCHARD_NO_MOUSE=1)
n	jump to next repo with new commits since last visit
space / a	select current / select all visible
x	clear all selections
y	copy the current repo's path to the clipboard

Git and repo actions

Key	Action
enter	repo detail (languages, instructions, code graph, GitHub PR/CI, agent footprints, working tree, commit graph, remotes)
d	view the working-tree diff (vs HEAD)
p / P	pull selected / all (fast-forward only)
f / F	fetch selected / all
b	switch branch
e / E	open in editor / change default editor
O	open repo(s) in browser (confirms for >1 repo)
+	clone a repo into the dashboard

Agent actions (Claude Code / Codex)

Key	Action
c	open the agent (Claude Code / Codex) in a new tab (confirms for >1 repo)
C	resume the agent's last session in the current repo
H	browse the agent's past sessions for the current repo and resume any one
R	search the content of past sessions across all repos, then resume one
A	one session across the selected repos: opens in the first selected, the rest attached via --add-dir (space-select 2+ first)
M	draft a commit message headlessly (shown in a window to copy / regenerate)
I	wire AGENTS.md into a new CLAUDE.md for the selected repos (so Claude reads it)
W	workspace presets: save a repo set, then launch a cross-repo session (A) on it
v	preview a repo's CLAUDE.md / AGENTS.md / README.md, rendered, with size and est. token cost

Code graph actions

Key	Action
B	build or refresh the code graph for the current selection
D	delete the selected repo graph cache
m	toggle automatic MCP graph wiring for agent launches

Search, stats, and filtering

Key	Action
S	search code across all repos
L	worklog - your commits across repos
T	stats page (languages, freshest/thirstiest, per-agent usage, harvest + agent heatmaps)
/	filter by text, or a branch: / name: prefix
tab	cycle quick filters (attention, dirty, behind, feature, at-risk, ai-touched, needs-md)
s / o	cycle sort (attention / name / synced / agent) / toggle grouping

App

Key	Action
r / w	refresh now / toggle live auto-refresh (also fetches remotes periodically; tune with ORCHARD_FETCH_SECS)
? / q	help & legend / quit

CLI

orchard [--config PATH]                  start the TUI
orchard [--config PATH] scan    [flags]  scan local repos
orchard [--config PATH] pull    [flags]  safely pull eligible repos
orchard [--config PATH] clone   [flags]  clone scoped GitHub org repos
orchard [--config PATH] preview [flags]  render the dashboard once
orchard [--config PATH] config           show resolved configuration
orchard [--config PATH] stats            summarize the orchard
orchard graph <subcommand> [flags]       build/query a repo code graph
orchard mcp [--repo PATH ...]            serve code graphs to AI agents
orchard update                           update orchard to the latest release
orchard version                          print the version
orchard help

Common flags: --root PATH, --concurrency N. --json is supported by scan, pull, and clone only. Run orchard <cmd> -h for per-command flags.

• scan - --root, --concurrency, --json
• pull - --all or --match RE, --root, --concurrency, --json
• clone - --org and --match RE (both required, so you never clone a whole org by accident), --include-archived, --root, --concurrency, --json
• preview - --root, --concurrency, --width, --height, --group, --detail NAME
• graph - build, delete, status, map, find, callers, blast, search, install-ast-grep
• mcp - repeat --repo PATH for a merged cross-repo graph; use --no-build to skip startup refresh

Configuration

All settings are optional; the default root is your current directory, so the simplest setup is no config at all.

If you only need to tell orchard where your repos live, pick one:

1. Run it from that folder: cd ~/code && orchard
2. Pass a root for one launch: orchard --root ~/code
3. Persist the root with your shell: export ORCHARD_ROOT=~/code
4. Use a config file when you also want saved clone defaults like org / scope

Precedence: CLI flags → environment variables → config file → built-in defaults.

The orchard config command doesn't change anything: it prints the resolved settings (root, concurrency, and which config file, if any) so you can confirm what orchard will use.

Environment variables

• ORCHARD_ROOT - default repo folder.
• ORCHARD_CONFIG - explicit config file path.
• ORCHARD_AI_CMD - explicit agent command for the agent keys (otherwise the first of claude / codex on PATH).
• GITHUB_TOKEN - token for orchard clone (falls back to gh auth token).
• ORCHARD_ADDDIR_MEMORY - set to 0 to stop a cross-repo Claude session (A) from loading the added repos' CLAUDE.md (on by default).
• ORCHARD_GRAPH_MCP - set to 0 to disable automatic graph MCP wiring when launching an agent.
• ORCHARD_AST_GREP_PATH - explicit path to an ast-grep/sg binary; otherwise orchard prefers its managed pinned copy, then PATH.
• ORCHARD_NO_UPDATE_CHECK - set to 1 to disable the daily check for a newer release.
• ORCHARD_NO_MOUSE - set to 1 to disable mouse capture (so your terminal's native text selection works).
• ORCHARD_FETCH_SECS - while live refresh is on, how often (seconds) to fetch remotes in the background so ahead/behind stay current. Default 300 (5 min); 0 disables background fetching (fetch on demand with f / F).
• ORCHARD_NO_ANIM - set to 1 to turn off motion (the launch intro, the row cascade, the count-up, and the "just tended" row pulse).
• ORCHARD_IDLE_SECS - seconds of idle before the petal screensaver wakes (default 600; 0 disables; Z starts it on demand).
• ORCHARD_TERMINAL_CMD - custom new-tab launch template when your terminal is not auto-detected.
• ORCHARD_DEMO - set to 1 to render fictional demo data (for clean screenshots and recordings).
• NO_COLOR - disable colored CLI output (no-color.org).

Advanced config file

The config file is a small key: value format with one nested scope: section. Copy config.example.yaml to config.yaml. Search order: --config → $ORCHARD_CONFIG → ./config.yaml → next to the binary → $XDG_CONFIG_HOME/orchard/config.yaml.

root: ~/Documents/GitHub
concurrency: 8
org: your-github-org
scope:
  match: "^(service|app)-"

Files orchard writes

Beyond the optional config.yaml, orchard keeps a little state under your config dir ($XDG_CONFIG_HOME/orchard, or ~/Library/Application Support/orchard on macOS), created lazily the first time it is needed:

• presets.json - your workspace presets (W).
• seen.json - the last time you visited each repo, for the n "new commits since last visit" jump.
• editor - your chosen default editor (E).
• graph/*.db - per-repo code graph SQLite databases, plus SQLite WAL/SHM sidecars while open.
• bin/ast-grep / bin/sg - orchard's managed parser backend when installed with orchard graph install-ast-grep.

These are plain, hand-editable files that orchard owns. Reads are fail-soft: if one is missing or corrupt, orchard falls back to a safe default (no presets, no last-visit, the editor picker) instead of erroring, and the next save rewrites it. The daily update check also caches its last result under your home cache dir. A malformed config.yaml, by contrast, is reported at startup, since that is configuration you declared on purpose.

When graph MCP wiring is enabled, orchard may also merge an orchard server entry into a project's .mcp.json for Claude Code and .codex/config.toml for Codex. It owns only that server entry/table and preserves unrelated settings.

Security & privacy

orchard runs locally with no telemetry. Network traffic only happens when you ask for it:

• git talking to your remotes (fetch / pull / clone).
• the GitHub API for open-PR and CI status, and for orchard clone.
• orchard graph install-ast-grep, which downloads a pinned ast-grep release zip from GitHub, verifies its SHA-256, and stores the binary locally.
• your agent (Claude Code / Codex), when you launch it (c / C / H / A) or draft a commit message (M, which runs claude -p or codex exec and sends the working-tree diff to the agent). The usage panel, AGENT column, and stats only read your local ~/.claude transcripts and ~/.codex rollouts - nothing is sent for those.
• the update check - one anonymous request to the GitHub releases API, at most once a day (disable with ORCHARD_NO_UPDATE_CHECK=1).

Privacy details:

• The GitHub token is read from GITHUB_TOKEN or gh auth token at the moment it's needed; it is never written to disk or printed, and tokens embedded in a remote URL are stripped before the URL is shown or opened.
• Pulls are fast-forward only and skip dirty repos - orchard never force-pushes, rebases, or discards work, and it never commits or pushes on your behalf.
• The graph MCP server is local stdio only, read-only, and returns graph metadata (names, signatures, paths, line numbers), not source file bodies.

See SECURITY.md for how to report a vulnerability.

Development

Built with Bubble Tea and Lipgloss.

make build       # build ./orchard
make test        # run the test suite
make test-race   # tests with the race detector
make lint        # gofmt check + go vet
make check       # lint + test (run before committing)
make cover       # HTML coverage report
make help        # list all targets

The codebase is split into small packages under internal/ (tui, git, github, repo, config, editor, lang, search, seen, termlaunch, claude, graph, mcp, agentcfg) with a thin main.go CLI. The logic lives in the unit-tested packages; the TUI is a Bubble Tea layer on top.

Cutting a release

Releases are automated with GoReleaser. Tag a commit and push the tag - the release workflow builds binaries for macOS and Linux (amd64 + arm64) and publishes them:

git tag v0.1.0
git push origin v0.1.0

Contributing

Issues and PRs are welcome. Please run make check before submitting. See CONTRIBUTING.md.

License

MIT