Context dies between sessions. Plumbing eats the one scarce thing — your attention. Work scatters across chats and is lost. tide is a synchronous, human-driven orchestration machine: pure CLI + markdown, no autonomy. You steer in plain words; the state lives in files you can read.
You're not slow. The tools are leaking the work faster than you can do it. Three leaks, every project, every week.
.tide/ — cat, grep, diff it.
A session starts empty and re-hydrates by reading. The thread is never lost.
No diagrams of an imagined system — these are the actual commands the session runs on your behalf, and what you actually see. You steer in prose; tide does the rest.
tide terminal drops you into a clean, logged-in, scoped Claude
session in your standard terminal — no new window, works in plain macOS
Terminal. Seeded with the right context, ready to go.
The session lands and states where everything is — the work stream, your role, and any drift. You don't explain the project to it; it explains the project to you.
You're oriented. What to read, what's live, what's waiting on a human — computed from the files, shown on entry.
You say what you want in plain words. The session carves an arc — one bounded unit — and binds a contract: your goal plus hard criteria. You sign once. A worker subagent builds into the arc, never touching anything else.
The session gets heavy. You say "handoff." tide handoff
distils the chat into the arc's workspace and forks a fresh terminal
that starts already working — on the focus, not on a pile of scrollback.
Carried, not re-briefed. The new session opens on the work, with the distilled thread already in its workspace.
The fresh session finishes the work. You review the report and proof, accept,
and land it. tide arc land merges the arc's delta into
CANON.md — the single serialization point. You look back and see it:
documented, criteria passed, durable.
The thread crossed two terminals and landed as durable truth. Nothing was re-explained. Nothing scattered. The project knows what it is — in a file you can read.
Namespaced subcommands that compose the way git <verb> does. Honest and concrete — every one is real.
CANON.md is the single serialization point; drift is flagged, never silent.README.md as a projection of canon — with a --check drift gate.orca by default, tmux as fallback.tide arc …, tide canon …, tide contract … — namespaced verbs that compose like git. No platform to host, just the point you lead from.
<project>/.tide/. No daemon, no server, no lock file. cat, grep, diff and git all just work on your state.
TIDE_ROLE. Orchestrator-only ops — canon merge, contract close — refuse to run as a worker.
.tide/. The machine runs itself.
Requires Python ≥ 3.12. Runtime is stdlib-only — no click, no web deps.
tide on your PATH under a 3.12 interpreter. Idempotent.
Then unfold a control-home: mkdir ~/control && cd ~/control →
tide init --name control → tide roster add myapp ~/code/myapp
→ run tide and start steering. The full command tree lives in
tide help.
tide doesn't ask you to be more disciplined about context, plumbing, or notes. It removes the work that required the discipline.
State lives in files. Your judgment is spent only where it's irreplaceable. Every unit of work lands as durable truth you can read.