Every Claude Code tab knows its own thread. None of them knows the other fifteen, and I was deciding every next move by hand. So I built a conductor: one job that reads every tab, proposes one next step each, and only pings my phone when the decision is really mine. The scarce resource was never tokens. It was my attention.
The count that started this: 16 tabs open, 3 running, 13 idle, and I could not tell you which of the 13 were waiting on me. The first piece is deliberately dumb. A Python script reads what already exists: the window file my VS Code extension writes, the live session leases, the tail of each transcript, my clear-and-pause handover notes, and the ticket board. Out comes one digest.json with one row per tab: how long it has been idle, how full its context is, the last prompt, the last reply, and one small flag that matters more than the rest: does the last reply end with a question?
Every 15 minutes a headless Claude Code run executes one command, /conduct. Plain rules handle the obvious rows first: an empty tab idle for 30 minutes can close, a tab with a handover note can resume. Only what is left goes to the model, which writes one proposed next step per tab with a reason. Then every proposal gets a trust class: close, resume, continue, open a new worker, and so on. Each class can run automatically or wait for me, and right now every one of them waits. Auto-steps stay off until I switch them on. Opening new worker tabs stays manual through 2026-10-05 no matter what.
Proposals show up on a /conductor page on my dashboard, sorted into Needs you, Next steps and Decided for you, each with a label. I read one, edit it if I want, and press Approve. That appends a line to a queue file. The VS Code extension from Episode 70 follows that file and types the text straight into the right terminal, then presses Enter. No port, no clicking into the tab. But it waits: only when the tab shows idle twice in a row, its last turn is done and quiet for 20 seconds, and I am not in that tab myself. A queued step older than 30 minutes goes stale instead of landing late.
The whole thing was built in two days, 29 commits between 2026-09-26 and 2026-09-27, and in the first 33 scheduled runs the log says auto-queued: 0 every time. That is on purpose. A tool that types into live terminals is a real power, so it starts on a short leash: forbidden text is refused, it never types into the tab I am using, stale steps are dropped, and a guard stops it after three conductor steps in a row on the same tab. The auto switch only goes on after a test run proves the round trip. Until then, the conductor proposes and I approve.
A conductor that pings me about all 16 tabs would just be a 17th tab. So every question gets a label on a five-step ladder, Go live, Your hands, Architecture, Path, Quick, and only the top three reach Telegram. If the model rates a question too low, a few text rules can raise it, never lower it. Each ping is keyed on the tab, the label and a hash of the question, so the same question never pings twice. Tap any image to enlarge it and read the exact prompt that drew it.




The obvious fix for 16 tabs is to let the AI answer its own questions. I did the opposite. The conductor reads everything, decides the easy things on paper, and spends my attention only where a decision is really mine: going live, needing my hands, changing the architecture. Tokens scale. My review time does not. The system that runs my work now manages its own review queue, and the first thing it learned was to stay quiet.
I open the conductor page, read one proposal, press Approve, and switch to VS Code. A few seconds later the text types itself into the idle tab and Claude picks up the work.
My tabs and projects stay private. The pattern travels: a dumb digest that turns every session into one row of facts; rules first and the model second; a trust class per action that starts manual; a decision ladder that decides what is worth a ping; and delivery that waits until the tab is idle and you are not in it. Everything in this episode is free and open — clone it, run it, make it yours.
/conduct: rules, then one LLM step per tab
cmd digest: idleSec, ctxPct, endsWithQuestion
template trust classes: auto off, open manual last
assets decision ladder + ping dedupe key
# repo soon. the pattern: digest.json → /conduct → proposals.json → Approve → queue.jsonl → term.sendText()
No GitHub? Comment CONDUCTOR on the post and the bot DMs you the link.
The conductor talks to me. Next: how my Claude Code sessions talk to each other. Durable mailboxes across machines, a doorbell that wakes the right session by name, and one Telegram word that merges a pull request.