A session runs out of context. The work does not.
You can compact it and keep going in the same conversation, and most of the time that is the right answer. But sometimes what you need is not one session lasting longer — it is a different session taking the whole line of work over, one that was not there for any of it and still has to be able to make judgements, and to disagree with you.
Why a mechanism, rather than pasting the summary across
Paste the summary and the receiver gets your conclusions without the things your conclusions rested on.
Conclusions are exactly the part that should not be inherited directly. A summary is one session’s account of its own work — the same kind of object as “I’ve implemented the fix and all tests pass”. A receiver holding only that can do one thing with it: believe it. If a step behind it was wrong, the error travels onward wearing the words already confirmed, and gets harder to find at every hop.
So what a handoff moves is not the summary. It is the sources: a file and a line, a command and its output, a document at a path that will still exist next week. A summary can be rewritten. A source cannot.
What a handoff is in Clawdline
A document with eight fixed headings, and a new session opened against it.
The headings, in order: OBJECTIVE, KEY DECISIONS, CURRENT STATE, REFERENCES, CONSTRAINTS & PRINCIPLES, OPEN THREADS, IMMEDIATE NEXT STEP, VERIFICATION. The two doing the real work are the fourth and the last — REFERENCES is the list of sources, and VERIFICATION is a handful of questions whose answers are deliberately not in the document.
The receiving session is reached by one sentence: go and read that document. The document then asks it for two things — walk REFERENCES and actually open them, and then answer VERIFICATION from those sources, not from the handoff document.
That second instruction is the whole design. Answering the verification questions from the document would be asking the summary to confirm the summary. Answering them from the sources is what makes the receiver’s understanding independent of the sender’s. One session here read a route table, drew the wrong rule from it, and told another session. The second replied that it had read the reference document and confirmed it. Both were wrong, and the exchange looked exactly like verification.
Two more things worth saying plainly:
- It opens a root, not a child. No timeout, no result file it owes back, no slot it spends. It is an ordinary session, in your ordinary list.
- The app reads exactly one thing: whether the document exists. Never what is inside it. That is deliberate — the contents are for the receiving session, not for a parser — and it is also the honest limit: nothing validates that a handoff document is any good.
Answered from the document
Top: the handoff document. Bottom: its verification questions. The answer comes from the document and returns to it.
Answered from the sources
Out to the sources first — a file, a line, a command's output — and the answer comes back from there.
A handoff, against just messaging another session
Clawdline does both, and neither substitutes for the other.
| Sending a message | A handoff | |
|---|---|---|
| Who receives it | A session already running, already holding its own context | A session opened for this, holding none |
| What moves | One line: a status, a finding, a coordination note | A whole line of work, and the sources needed to keep judging it |
| What it costs | Almost nothing. One extra line in the other session’s next turn | A fresh session, reading from cold |
| Who is responsible | Nobody moves. The work is still the sender’s | The receiver reports to the person, in its own tab |
| What you write first | That one line | Eight headings, with REFERENCES that genuinely open |
The dividing line is whether the other session already has your context.
If it does, a message is enough and obviously cheaper: they already know what you are talking about, and you are adding the one thing they did not have. That is why the message route is deliberately narrow — it delivers a message, not an assignment. It hands over no responsibility and it does not get to bypass what a task declared it would write.
If it does not, messages stop working. You can send a hundred and the other session still will not know how the decision three hours ago was reached. That is what a handoff is for, and its cost is honest: you have to write the document first, well enough that a stranger can open it.
The combination that hurts is using a message to do a handoff’s job — “you take this over” sent to a session with no context, which will do exactly that, on premises it invented for itself.
What it does not do
It does not record whether the references were opened, and it does not know whether the verification questions were answered from the sources or from the document. What Clawdline knows is that a handoff was created, and whether the first line reached the session it named.
Writing the difference down does not make the middle step happen. It makes its absence visible, which is worth more than it sounds: an afternoon lost to a false rule is usually lost because nobody could see where the rule came from.
One property surprises people: a handoff is a copy of state, not a transfer of ownership. The sending session does not have to end. Fork a line off to run in parallel and you have two equal roots in one tree, neither of them the other’s parent.
Where to look next
The workflows guide covers project rows, dispatch, schedules and delivery in order.
And if what you actually wanted was to hand out one bounded task and get the result back, that is a dispatch rather than a handoff, and it has a limit of its own.