<![CDATA[Amith GC]]>https://amithgc.hashnode.devRSS for NodeThu, 05 Nov 2026 19:22:29 GMT60<![CDATA[How I built Quarters: a Go workspace for parallel CLI coding agents with passkey phone access]]>https://amithgc.hashnode.dev/how-i-built-quarters-a-go-workspace-for-parallel-cli-coding-agents-with-passkey-phone-accesshttps://amithgc.hashnode.dev/how-i-built-quarters-a-go-workspace-for-parallel-cli-coding-agents-with-passkey-phone-accessTue, 03 Nov 2026 18:46:59 GMTWhen you run one coding agent in a terminal tab, any terminal emulator works. When you run Claude Code, Codex, Gemini CLI, or Aider across ten repositories at once—each with its own dev server, database port, and permission prompts—standard terminal tabs start to break down.

You end up cycling through tabs to find out which agent stopped five minutes ago to ask a question, or wondering how to undo a prompt that touched twelve files without wrecking your git index, or wishing you could approve a migration from the sofa on your phone.

I built Quarters (quarters.amithgc.com) to solve that workflow for myself. It is a native macOS app (plus a headless Linux server; Windows is supported as a browser client only) and is free and open source (MIT).

Independence note: Quarters is an independent open-source project. It is not made by, affiliated with, or endorsed by Anthropic, OpenAI, Google, GitHub, or the makers of the other agents it runs.

Here is how the three core pieces work under the hood: PTY session multiplexing across desktop and mobile, zero-index-touch git checkpoints before every prompt, and passkey-paired remote access.

1. One PTY per session, shared across the Mac window and phone browsers

Quarters is built with Wails: a Go backend driving a plain ES-module JavaScript frontend (no bundler) inside the system WebView, with xterm.js rendering each terminal.

Each project gets its own "room" (internal/projects), and each tab inside a room—whether it is an agent (claude, codex, gemini, aider, opencode, copilot, devin, amp, goose, qwen, agy, or agent) or a shell—runs in a pseudo-terminal managed by Go (internal/session).

Because the Go backend owns the PTY stream:

  • Multi-window & phone sync: The Mac window and any connected phone or laptop browser subscribe to the same live PTY session over a WebSocket. Whichever window you are actively typing in sets the terminal's dimensions.
  • "Your turn" detection (◐ waiting): Quarters watches terminal activity and session logs so when an agent finishes a turn or pauses for input in a background project, the room gets marked and moves to the top of the ACTIVE list (sorted longest-waiting first, reachable from anywhere with ⌘J).
  • In-process subagents: When launching Claude Code, Quarters passes --settings '{"teammateMode":"in-process"}' (unless you set your own --settings) and strips inherited TMUX or STY environment variables. That keeps subagents inside the tab you can see on both your Mac and your phone instead of spawning invisible tmux panes.
  • Low idle footprint: Git status checks and file watchers only run when filesystem events fire, and timers pause while the window is hidden. Measured on a Mac with 14 projects open, Quarters sits at roughly 2% of one CPU core when idle in the background.

2. Snapshotting every prompt without touching your git index (refs/quarters/checkpoints/)

Every time you send a prompt to an agent, you want a clean "undo" button in case the agent goes down the wrong path—even if you had uncommitted work in your working tree before the prompt started.

Using git stash or commits on your current branch causes constant friction with your real staging area. Instead, Quarters snapshots the project before every prompt using a temporary git index:

  1. Quarters copies the current index state into a temporary GIT_INDEX_FILE.
  2. It stages all non-ignored working-tree files into that temporary index and writes a tree object (git write-tree).
  3. It creates a commit object stored under refs/quarters/checkpoints/ (keeping the last 50 per project).

Because these commits live under refs/quarters/checkpoints/:

  • Your actual branch, HEAD, staging index, and stash are never touched.
  • A plain git push never uploads checkpoint commits to your remote.
  • Opening the Checkpoints panel shows the exact file-by-file diff since any prompt. Clicking Restore takes a fresh checkpoint first (so even a restore is reversible) and puts your files back where they were.

Similarly, the built-in Git commit dialog refuses to stage or commit files that look like secrets (.env, *.pem, private keys)—stopping the commit and naming the blocked files before they ever reach history.

3. Remote access from a phone: passkeys, loopback listener, and origin checks

Because a terminal tab runs with your user's privileges, anyone who can type into it can run commands as you. Remote access is designed to be safe to expose; read SECURITY.md for the full threat model and implementation details.

Key design choices in internal/remote:

  • Off until you start it: The HTTP/WebSocket server does not run until you explicitly start it (⌥⌘R or Remote Access → Start server). By default it binds only to 127.0.0.1 and expects to be reached through your own tunnel (such as Cloudflare Tunnel or Tailscale Funnel), so no router ports are opened.
  • Paired from the Mac with WebAuthn passkeys: Clicking Pair a device on the Mac generates a QR code carrying a single-use token in the URL fragment (never logged, valid for 10 minutes, burned after 5 failed attempts). Signing in uses WebAuthn passkeys (go-webauthn) requiring device user verification (Face ID, Touch ID, or PIN) bound to your domain. If a passkey's signature counter ever moves backward—a sign of credential cloning—Quarters refuses it and alerts you on the Mac.
  • In-memory SHA-256 session hashes & strict allowlists: Sessions are random 256-bit tokens kept only in memory as SHA-256 hashes (restarting Quarters signs everyone out) with __Host- prefixed, HttpOnly, Secure, SameSite=Strict cookies. Every WebSocket message re-verifies the session, checks Host and Origin headers to block DNS rebinding and cross-site WebSocket hijacking, and passes through an explicit RPC allowlist (remote_app.go) that keeps device pairing and security settings Mac-only.
  • Phone-friendly cards + full terminal: On a phone browser, you can read the conversation as clean message cards, approve or reject tool prompts with a tap, queue your next prompt while the agent works, or flip to the live xterm.js view.

Try it or read the code

Quarters is free and open source (MIT):

If you run multiple CLI agents across projects—or have solved terminal multiplexing and mobile approvals differently—I would love to hear what your setup looks like.

]]><![CDATA[How I make sure none of my puzzles needs a guess]]>https://amithgc.hashnode.dev/how-i-make-sure-none-of-my-puzzles-needs-a-guesshttps://amithgc.hashnode.dev/how-i-make-sure-none-of-my-puzzles-needs-a-guessMon, 02 Nov 2026 12:50:32 GMTI've always hated the moment in a Minesweeper game where you've done everything right and you still have to flip a coin. So when I started building Little Grids, a collection of 16 small grid puzzles, I set myself one rule: a logic board only ships if it can be finished by reasoning alone.

That rule turned out to be most of the work. Every game started life as a browser game, and each one has its own little generator and solver written as Node scripts. The boards in the app are exported straight from those scripts and never edited by hand. Here's how a few of the games are checked.

Mines. Each board has a fixed opening. A solver starts from that opening and only makes moves it can prove are safe. If it ever gets stuck, the board is thrown away. So you never face a 50/50, and the board doesn't move mines around after your first tap to hide that.

Nonogram. I drew 42 pictures by hand, in 5x5, 10x10 and 15x15. A picture is kept only if solving it one line at a time, with no guessing, finishes the whole thing. Some of my favourite drawings didn't survive that test, and I had to redraw them.

Shikaku. The generator cuts the grid into rectangles first, then an exhaustive solver checks the clues. A board is kept only if there is exactly one answer.

Loop and Switch Off are solvable by construction. Loop scrambles a random spanning tree, and Switch Off starts from a board with every light off and applies random taps, so there is always a way back.

Word Snake lays each word as a path that turns, adds decoy starting letters, and then searches the finished grid to make sure every word is really there.

The app itself is written in Flutter, and the Dart game engines are tested against the web code: for each game, a script runs the web engine and solver and saves real solutions, and the Dart tests replay them move by move. If the two ever disagree, the test fails.

Why bother? Because a puzzle that needs a guess isn't really a puzzle. When you're stuck in Little Grids, there's always a reason you can find, and the hint (a ghost finger that shows the next move) is computed by the same solvers that checked the board.

Little Grids is free to download on iPhone, iPad and Mac, and every game has a free part with no time limit: https://apps.apple.com/app/id6816600512

This Sunday, 8 November, there's a Big Sunday board event in the app if you want to try it on something bigger.

I'd love to hear from other people who build puzzles: how do you check yours?

- Amith

]]>