v0.11.0

Sync 0.11.0

Three things this version is: a conversation can hand work to another
conversation and get the answer back, an extension can open a real shell in a
folder, and the phone stops being a viewer.

---

Nested conversations

A conversation can start another one, and what that one finds its way back.

Where the work happens. Work delegated from a conversation is carried out in
that conversation's own working tree — the second agent sees the first one's
files rather than a fresh checkout. Every delegated run starts when it is
ordered, however many are already going: two of them at once are two agents
editing one set of files, and the tree is the person's, so the decision is
theirs. Holding the second back until the first finished would cost the thing
delegating is for, and it would be an invisible wait — the turn that is waiting
has not been sent, so nothing in the transcript says why an hour passed.

What comes back. The child is told what it came out of. Whatever it says
last is the answer, and it is the only thing that travels: the parent cannot
read the rest of the child's transcript. That keeps a hand-off the size of an
answer rather than the size of a session.

How deep it goes. A chain is two conversations deep. Work delegated from a
delegated conversation is filed beside it rather than under it, and the agent is
told so in the same words it is told everything else.

When it arrives. Nothing is raised and nothing is polled. An outcome is
delivered when the conversation that asked for it is open and not in the middle
of a turn; if it is closed, the answer waits — a conversation is resumed by a
person and by nothing else, and raising an agent two days later to hand it a
paragraph would be spending somebody's money without asking. There is no tool an
agent can call to ask whether its delegated work is done: work that runs for a
day would be asked about thousands of times for one answer, and the answer
arrives as an ordinary turn anyway. Several finished pieces arrive as one
message rather than as several interruptions of whatever the conversation went
on to do.

Using it. Delegation is a capability rather than a button. An extension that
declares agents.acp and work.agent starts one with startSession({ parent })
or orders one with work.order({ parent, title }), naming the conversation it
is delegating from; the host does the rest. What a person sees is a second
conversation in the list, filed where its parent is filed — what it is about and
who ordered it are read from the parent, so no caller can file one somewhere
else — and, when it finishes, a turn in the parent that begins with the work
having finished and carries the answer under it. An outcome nobody has come back
for is kept per project rather than dropped.

A terminal, in a folder, with a screen the package draws

An extension can open a shell. What it opens runs whatever is typed into it, in
the folder it was opened in, as the person who opened it — the card says that in
those words, because nothing narrower would be honest.

The process is Sync's and the screen is the package's, and the two fail
differently: a screen is drawn, hidden, resized, reloaded and thrown away, and a
build that stopped for any of those would be a build that stops when somebody
looks at something else. So a package is handed bytes with an offset on them,
and a quarter of a megabyte of scrollback is kept per terminal.

A terminal belongs to the project, not to the section that opened it.
Leaving a section, hiding it or reloading it changes nothing; closing the
project is what ends them. The capability is read from the manifest when a
terminal is opened and never again — a manifest read per keystroke is a file
read behind every character typed — and what stands in for it afterwards is that
a terminal is refused to anybody but the package that raised it. One screen at a
time: watching a terminal retires whoever was watching it.

The phone becomes a working window

Sync on iPhone now holds conversations rather than showing them. Everything
about talking to an agent travels the paired computer's channel, and each call
is answered by the very function the Mac's own window calls — not a copy and not
a narrower version, so a conversation started at the desk is continued on the
phone because there is only ever one conversation.

A device asks to watch a conversation and is answered with a number; every word
that conversation says afterwards arrives under that number as it is written,
rather than in one piece at the end. A watch says where to start, so a
connection that dropped is taken up from there instead of replaying the
transcript. Watching from a phone does not take the live view away from the
window at the desk.

The window is the same one the Mac shows, arranged for a different machine: the
three columns of a frame become a stack a person walks into, and a column's
controls appear in the bar at the foot of the screen, because that is where the
platform keeps controls that act on a list. The project a phone had open
survives the system reloading the webview. Settings is a sheet holding the one
section only a phone can answer — which computer this is, and how to stop being
on it.

A project's sections say which machine they need. A package that opens a
shell or works through a stored credential is drawn in the phone's list and
cannot be opened there, with the reason in a sentence. It stays installed: what
a manifest is checked against is a project, and a project is one repository open
on more than one machine, so a phone that withdrew a package the computer runs
would be deciding for the computer.

The Mac and the phone carry one version deliberately — somebody holding both
should be able to say which is older without learning two numbering schemes.
This release page carries the macOS installer; the phone goes by its own road.

For extension authors

The surface is 3.10.0, three minors on from 3.7.0, and every package stating
^3.0 goes on installing.

• ExtensionHost carries a terminal beside net and vault, with
  TerminalOpening, TerminalRow, TerminalSize and TerminalEvent. The
  terminal capability joins the list.
• capabilitiesHere() is what the machine in front of somebody honours, as
  against SYNC_CAPABILITIES, which is what the build publishes. Read the first
  before degrading deliberately. unavailableHere() says in a sentence why a
  package that is otherwise fine does nothing here.
• SourceTreeItem gains emphasised, for a row that is waiting on the person
  reading the column, and SourceListItem gains menu, so a secondary click
  means the same thing in both source lists.
• SessionStatus.queued is no longer reported by anything: a delegated turn
  starts when it is ordered. The member stays in the union — dropping something
  a status can be would be a major spent on a word no package can be handed.

The contract is published as @sync-buzz/extension-api.