A Make It Ryne Playbook

Put Every Terminal Window on One Dashboard

One command shows every terminal session and every project on your machine, flags the one that is stuck waiting on you, and lets you jump in and out with a single keystroke. Setup takes about 15 minutes.

What you'll walk away with

A session layer that keeps every project alive even when you close the window
A multic command that opens a live dashboard of all your sessions
A visual flag on any session that is waiting on a human, including Claude Code permission prompts
A one-keystroke attach and detach loop so you never hunt for a window again
A helper that tracks every new project from the second it starts

Quick honesty note before we start: multic is what I named my session hub. Under the hood it runs on tmux, the battle-tested session manager that ships in every package manager on earth. You are not installing some fragile new app. You are wiring a tool that has existed for 15 years into the exact workflow from the video, and you keep it forever.

Install the session layer

Everything runs on tmux. It lets terminal sessions live in the background, detached from any window, which is what makes a dashboard of all of them possible.

Terminal (Mac)brew install tmux

Terminal (Linux)sudo apt install tmux

Verify it with tmux -V. Anything version 3.x or newer is perfect. That is the entire install.

Drop in the config

Create a file called .tmux.conf in your home folder and paste this in. Five lines, each one earning its spot.

~/.tmux.conf# click and scroll work like a normal terminal set -g mouse on # flag any session that rings the bell (this powers the "needs you" alert) set -g bell-action any setw -g monitor-bell on # alert silently in the session list instead of flashing the screen set -g visual-bell off # refresh status info every 5 seconds set -g status-interval 5

The bell settings are the secret. When a program inside any session rings the terminal bell, tmux marks that session with a ! in the dashboard. That mark is the flagged row you saw in the video.

Create the multic command

Now build the one-command dashboard. Add these two functions to your ~/.zshrc (or ~/.bashrc if that is your shell).

~/.zshrc# multic: open the live dashboard of every session multic() { if [ -n "$TMUX" ]; then tmux choose-tree -Zs else tmux new-session -A -s hub \; choose-tree -Zs fi } # mnew: start a new tracked project session # usage: mnew <name> [directory] mnew() { tmux new-session -d -s "${1:?usage: mnew <name> [dir]}" -c "${2:-$PWD}" echo "tracked: $1" }

Reload your shell with source ~/.zshrc, then type multic. You will land in a live tree of every session on the machine, with a preview pane showing exactly what each one is doing right now. Empty on the first run. We fix that next.

Register your projects

Give every active project its own named session. One line each, pointed at the project folder.

Terminalmnew dispatch ~/code/dispatch mnew site ~/code/my-site mnew scraper ~/code/photo-scraper mnew invoice-agent ~/code/invoice-agent

Each session starts detached in the right directory, already tracked. Attach to one, start whatever runs there (a dev server, a build, a Claude Code agent), and it keeps running whether you are watching or not. From now on, when you start work on anything, mnew it first. Two seconds of habit buys you a machine where nothing gets lost.

The mindset shift: stop thinking in windows. Windows are disposable glass you look through. Sessions are the actual work, and they survive closed laptops, closed terminals, and your memory.

Wire the "needs you" flag for Claude Code

This is the part that saves whole afternoons. If you run Claude Code agents, tell Claude to ring the terminal bell when it needs input.

Terminalclaude config set --global preferredNotifChannel terminal_bell

Now the chain works end to end: Claude Code hits a permission question, rings the bell, tmux catches it, and the next time you glance at multic that session carries a ! flag. In the video that was my invoice agent, parked on one question for 22 minutes. The dashboard surfaced it in two seconds. If a newer Claude Code version renames this setting, run claude config list and look for the notification channel option.

This works for anything, not just Claude. Any script can flag itself by printing the bell character when it finishes or gets stuck:

End of any long scriptprintf '\a'

Run the loop: attach, answer, detach

The whole daily workflow is four moves, and your hands never leave the keyboard.

Open the dashboard: type multic. Every session, live previews, flags on whatever needs you.
Attach: arrow to a session and hit Enter. You are inside, exactly where that work left off.
Back to the overview: press Ctrl+b then s. The dashboard reopens without leaving tmux.
Detach completely: press Ctrl+b then d. Everything keeps running in the background.

That is the entire system. Morning check-in becomes: multic, scan for flags, answer whatever is blocked, detach. The agents do the work. You clear the bottlenecks. The terminals report to you.

Level up later: once this feels natural, look at the tmux-resurrect plugin so your sessions survive a full reboot, and at tools like claude-squad if you scale to many agents on many branches. Same workflow, more firepower.

The 15-minute checklist

Install tmux and confirm with tmux -V
Paste the 5-line config into ~/.tmux.conf
Add the multic and mnew functions to your shell config, then source it
Register every active project with mnew
Set Claude Code notifications to terminal_bell
Run multic and practice the loop: Enter, Ctrl+b s, Ctrl+b d
Tomorrow morning: multic first, everything else second

Want the other 50+ playbooks?

This is one of the 50+ free Make It Ryne playbooks: the exact setups I use to run AI agents, content systems, and client work without losing my mind or my afternoons.

Get all 50+ free playbooks