HOW IT WORKS TOGETHER

Three things, three lifetimes. A THREAD lives for months — it is the perspective: the goal, what must not be forgotten, the decisions, the works. A SESSION lives for hours — one agent in one terminal, and the list of what it did. An ACT lives for a moment — one line: what was done, with proof.

The agent writes acts. The thread is read back from them. You change the thread by hand — a yes, a done, a decision. That is the whole machine; the rest of this page is where each piece lives and which command touches it.

Русская версия — как всё работает вместе.

ONE PICTURE

   YOU  ── terminal: "look at this", "hand off" ──▶  SESSION
    ▲     board: inbox · threads · works · decisions    │
    │                                                   │  acts, through the tide CLI
    │   your word: yes · done · a decision              ▼
    └───────────────────────────────────────────────  THREAD
                                    goal · main · decisions · works · sessions

Hard rules sit on the CLI as hooks; soft rules sit in the prompt and stay short.

THE THREAD

A thread is a folder: .tide/arcs/NN-@name/. Inside — plan.md with the goal and a MAIN section that is printed before anything else, decisions.md, and arcs/ with one passport per session. Works live next to it in .tide/arcs/works/.

tide thread                     # the whole thread on one screen
tide thread --check             # what burns: promises without a work, silent arcs

You'll see MAIN first, then the plan and its open steps, decisions in force and which work carries each, where the lead session stands, works in flight, what waits for your hand, and the sessions newest first.

THE SESSION

Each session has a passport, arcs/NN-slug/arc.md: its role, a cursor, and pulse lines. The newest accepted session leads the thread; earlier ones stay as open history you can return to. A pulse is ten seconds and not a report:

tide offload <arc> --cursor "what I'm doing now" --next "step · step" "what I did"

Without pulses the board is blind — a hook nudges a session that has gone quiet.

THE ACT

Today an act takes three shapes, and each is one line with a time stamp in a journal: a pulse, a checked item, a dispatch.

tide offload <arc> "found the answer — it's in workspace/notes.md"
tide work check 12 3 --proof "started it — it answers"    # no proof, no check
tide work dispatch 12 --to "builder"                       # a worker was sent

tide work show 12 prints a work's journal: every gesture a line, your words in it.

A TICK

The agent's loop is two steps: read, then act.

tide thread                                  # where am I
...one thing gets done...
tide work check 12 3 --proof "..."           # or a pulse

Nothing is kept in the conversation that the next session would need — if it matters, it is an act.

HOW THE AGENT THINKS

A session is Claude Code with tide around it. In order, from waking to handoff:

  1. WAKES BY SPARK — tide menu or tide go opens a terminal with Claude Code already in context; a handoff seed, if one hangs on the thread, is the first thing it reads. The start hook prints the status: threads, candidates, what is unread.
  2. GETS ITS PROMPT IN LAYERS — Claude Code's own, then the role (head or worker), the project's canon from .claude/rules/, the thread's plan with MAIN first, and the seed. These are the soft rules; they are kept short on purpose.
  3. READS ONE SCREEN — tide thread. Then tide work show for the one work it is about to touch, not for all of them.
  4. TALKS, THEN ACTS THROUGH THE CLI — your words come in the terminal; every change the agent makes to the thread goes out as a command: a pulse, a check with proof, a dispatch, a candidate, a decision. A call is visible, and a hook can sit on it.
  5. USES ITS OTHER HANDS — skills and MCP servers (a browser, a tracker, a calendar) are Claude Code's own; tide does not wrap them. What came out of them lands in the thread as an act or a file.
  6. OFFLOADS BY RHYTHM — a pulse at each turn or decision; a hook nudges after fifteen quiet minutes.
  7. SENDS WORKERS — with full hands, into the thread's workspace; the dispatch is a line in the work's journal, the result is a file.
  8. HANDS OFF — tide handoff distils the session into a seed; the next session takes it and pulses. Or no seed at all: with acts written, the thread is enough.
tide thread                                  # one screen
tide offload <arc> --cursor "..." --next "..."   # a pulse, by rhythm
tide work check 12 3 --proof "..."           # an act, through the CLI
tide handoff                                 # a seed for the next one

Nothing here is a feature the agent must remember. The head cannot edit files, a check refuses without proof, silence gets a nudge — the rails are hooks, so the prompt stays about the work.

HEAD AND WORKERS

The session you talk to is the head. It reads, talks and runs tide; a role gate stops it from editing files itself. It sends workers with full hands, and each dispatch is a line in the work's journal. A worker writes its findings as a file into the thread's workspace; the head checks the item with that path as proof — "done" is the file, not the report about it.

GATES

Hard rules are hooks on the CLI, not sentences in a prompt:

  1. a check needs proof — the verb refuses without one
  2. done is your hand alone — tide work close --word "…", or the button on the live board
  3. the head may not edit files — it dispatches
  4. a silent session is nudged to pulse

Soft rules — the canon, the role, the thread — ride in the system prompt and are kept short, so the agent stays in the work rather than in the rulebook.

HANDOFF

A handoff distils the session into a seed and hangs it on the thread; nobody's terminal opens on its own. The next session takes it in three gestures:

tide handoff                    # from the old session: seed on the thread
tide handoffs take              # from the new one: accept
tide offload <arc> ...           # first pulse — the gate is closed

The seed is the entrance. The memory is the thread. One work was carried through five handoffs in a test; on two of the seams there was no seed at all — the sessions rebuilt the picture from the thread's plan, decisions and journals, and nothing was lost.

SURFACES

One structure, two views. The files under .tide/ are the truth; the agent and you look at them through different glasses.

FOR THE AGENT — arcs and acts. It moves by folders: the thread, a session's passport, a work's card; and by lines inside them: pulses, checks, dispatches. It reads with tide thread and tide work show, writes only through the CLI, and never opens the board.

FOR YOU — the board, through the prism of threads:

tide board --open               # http://127.0.0.1:8765

Pick a thread and you see its sessions newest first, the lead marked; open a session and you see its passport — cursor, acts; the handoff seed hangs on the thread where it was left; a past session reopens from its card, and a terminal comes back into that context. Works, decisions and the inbox table — only what waits for your hand — sit on the same page.

Nothing on the board is typed into it. Every card is a file the agent wrote through a verb; the board re-reads .tide/ and draws.