Verbs: Files and worktrees
Verbs: Files and worktrees: part of the Control Protocol of TUIOS.
This page is one part of docs/protocol.md of the tuios repository. The Control Protocol page lists every part.
new-worktree
Create a git worktree of a repository and a session in it. The worktree goes
where the daemon's [worktree] path template puts it (see
Where worktrees go), by default under
$XDG_DATA_HOME/tuios/worktrees/<repo>/<branch>, and the session is
named <repo>-<branch> with every slash in the branch turned into a hyphen. A
branch that does not exist is created from base, or from HEAD. A template
that does not render is refused with internal, and nothing is created.
Params: repo (a directory inside the repository, required unless
repo_url is passed), branch (required), base, name, command (argv
for the first window instead of a shell), repo_url, repos_root, clone.
repo_url names the repository by its origin URL, for a caller on another
machine where a path means nothing. The daemon finds its own checkout whose
origin is the same repository, after folding the spellings git accepts for one
remote (https://github.com/o/r, git@github.com:o/r.git and
ssh://git@github.com/o/r are one repository). It looks under repos_root
(absolute, or ~/ for the daemon's home) three levels deep, or when that is
omitted under ~/src, ~/dev, ~/code, ~/projects, ~/repos, ~/git,
~/work, ~/go/src, the home itself one level deep, and
$XDG_DATA_HOME/tuios/repos. Two checkouts of one origin are refused with
invalid_params, the hint listing both, and none is repo_not_found. With
clone, none is cloned into repos_root or $XDG_DATA_HOME/tuios/repos. A
clone fetches only https, ssh and git URLs, or user@host:path: a local
path, a file URL, a transport helper such as ext:: or anything starting
with a hyphen is refused before git runs, and git runs with
GIT_ALLOW_PROTOCOL=https:ssh:git, no terminal prompt and ssh in batch mode.
The result carries cloned: true.
Request:
{"verb": "new-worktree", "params": {"repo": "/src/api", "branch": "feat/retry", "base": "main", "command": ["claude"]}}
{"verb": "new-worktree", "params": {"repo_url": "git@github.com:acme/api.git", "repos_root": "~/src", "branch": "feat/retry"}}Response:
{"result": {"type": "worktree_created", "session": "api-feat-retry", "repo": "api", "repo_root": "/src/api",
"branch": "feat/retry", "created_branch": true, "path": "/home/u/.local/share/tuios/worktrees/api/feat-retry",
"window_id": "...", "pty_id": "..."}}When the worktree is inside the repository and git does not ignore it, the
result carries warning, a sentence that names the folder to ignore. The
worktree and session are made all the same.
An after-new-worktree hook runs in the worktree before the first window
starts, and the verb waits for it (60 seconds at most). When it fails, the
worktree, the session and the first window are kept, and the result carries
hook_error: the exit code and the last lines of the hook's stderr. fan
puts the same field on each session it lists. See HOOKS.md.
A session whose first window starts inside a worktree made by hand is recorded
the same way, by reading the directory. list-sessions carries the record as
worktree on the session, and it is what the rail groups by.
list-worktrees
List the sessions whose directory is a git worktree. A session in the
repository's main checkout reads as a row with main true. No worktree verb
acts on such a row.
Params: repo (filter by repository name), group (filter by fan-out stem),
changes (run git in each and report changes, ahead, merged and
merged_into; off by default).
Request:
{"verb": "list-worktrees", "params": {"changes": true}}Response:
{"result": {"type": "worktree_list", "total": 1, "worktrees": [
{"session": "api-feat-retry", "repo": "api", "repo_root": "/src/api", "branch": "feat/retry",
"path": "/home/u/.local/share/tuios/worktrees/api/feat-retry", "base": "main", "group": "",
"managed": true, "gone": false, "main": false, "state": "working", "harness": "claude-code", "windows": 1,
"attached": false, "prompt_status": "", "prompt_note": "", "changes": 3, "ahead": 1,
"merged": false}]}}merged is true when the branch has changes of its own and its base already
holds them. A merge commit, a fast-forward, a rebase and a squash all count.
The daemon checks base, then the upstream of base when it has one, as git
last fetched it. It never fetches. merged_into names the ref, and is present
only when merged is true. With no base, the daemon checks the branch the
main checkout has checked out.
When the base does not hold the branch tip, the branch must change something
against its merge base with the base. A commit and its revert change nothing,
so they are not merged. Then git merge-tree --write-tree must give the tree
of the base itself. It runs with a temporary object directory, so the
repository gains no objects.
When the base holds the branch tip, the branch's reflog decides. The branch is
merged when an entry made a commit that the tip holds and start_commit does
not. A branch that only fast-forwarded to commits of its base is not merged. A
branch with no reflog is not merged. The answer is cached per branch tip and
base tip.
gone is true when the worktree directory no longer exists. The session is
kept, so what its agent printed can still be read. state is the agent state
rolled up over the session's windows.
remove-worktree
Remove a worktree session's worktree with git worktree remove, and kill the
session. Uncommitted changes are refused with worktree_dirty unless stash
moves them into the repository's stash as tuios: <branch> or force discards
them. force is the only option that discards work. The branch is never
deleted, and the daemon never runs git worktree prune.
Params: session (required), stash, force, keep_session.
Request:
{"verb": "remove-worktree", "params": {"session": "api-feat-retry", "stash": true}}Response:
{"result": {"type": "worktree_removed", "session": "api-feat-retry", "branch": "feat/retry",
"path": "/home/u/.local/share/tuios/worktrees/api/feat-retry", "repo": "api", "changes": 3,
"stashed": true, "stash_message": "tuios: feat/retry", "discarded": false, "session_killed": true, "branch_kept": true}}fan
Fan one prompt out across several agents. Creates count worktrees and
sessions, starts the agent in each, and types the prompt into each agent once
it is ready to read: idle or done. An agent in needs_input is left for
the person to answer, and the prompt is typed after. unknown is not ready for
a harness whose manifest has an idle rule, which reaches idle from its prompt
box or title (see Changes to existing verbs); if it never does, the prompt is
left not_sent when the wait ends, and prompt_note says to send it with
send-text. The prompt goes in as one paste and is submitted with the
harness's submit key, a carriage return for every bundled harness (see Changes
to existing verbs). The agent then has five seconds to
show it took the prompt, the same check ask-agent makes. The verb returns as
soon as the sessions exist. list-worktrees reports prompt_status per
session: pending, held, sent, not_sent with a prompt_note, or
stalled with a prompt_note when the prompt was typed and the agent showed
no sign of taking it. A stalled prompt may still be in the agent's input box.
held is a prompt whose agent has not been ready for 30 seconds and is not on
needs_input: the Inbox holds a question for its pane saying it waits at a
screen tuios does not recognise, and the prompt is typed as soon as the agent
is ready. The question closes when the prompt is typed or given up on, or when
the pane's state changes. Once the prompt is typed, prompt_ready_by says on
what: idle, done, or quiet for unknown on a harness that cannot show
idle. The harness the daemon started counts from the start, before detection
has named the pane's harness.
A fan's sessions reach each other, so joining one is never implicit. A
name that is already a fan in the repository, or is being made by another
call at that moment, is fan_exists for every caller, the person included,
and nothing is made. To add attempts to a fan on purpose, pass join with a
session of that fan (name may then be omitted): the caller must reach that
session, which the person, a pane with admin, the fan's own panes and the
pane that started it do. Without name, the name fan makes from the prompt
moves on to a free one (-2, -3). A name can have only the letters A to Z
and a to z, the digits 0 to 9, and / . _ -. Any other character is refused,
and the error names it. A refusal lists the fan's sessions only to a caller
that reaches them.
Each new fan gets a random fan_id. Its sessions save it, and a join copies
it. A fan's sessions are the ones with the same group, repository and
fan_id, so reach, compare-fan, keep-fan and review-diff --against go
by it. A fan made under a name while a fan of that name was saved and not
running, which disable_auto_restore allows, stays a fan of its own when
the saved one comes back, in any order and across restarts. Two records
from before the field have no fan_id and match by name. list-worktrees
rows, the fan reply and compare-fan carry fan_id.
An agent is one string, the way a person types it: a harness id or program
name, or any program, with its arguments after it ("codex --model o5"). It
is split into words the way a POSIX shell splits them, single and double
quotes and backslashes included, and exec'd directly; nothing is expanded or
substituted, and no shell runs. A path must be absolute. A program no manifest
recognises is ready only once it reports a state of its own.
Params: count (1 to 16; required unless prompts sets it), agent (one
agent for every session) or agents (a list, cycled across the sessions;
one of the two is required), prompt (one for every session) or prompts
(one per session, in order; count must equal its length when given), repo
(required unless repo_url is passed), base, name (branch stem),
ready_timeout (milliseconds, default 600000), env (an object of variable
names to values, on top of the daemon's environment; PATH in it is where the
programs are looked up), and repo_url, repos_root and clone as for
new-worktree. The result names the checkout used as repo_root.
env rules: at most 64 variables, a value at most 32 KiB and all of them at
most 256 KiB; a name is [A-Za-z_][A-Za-z0-9_]*; TUIOS_ names, TMUX and
TMUX_PANE are refused with invalid_params, since tuios sets the first for
every pane and strips the others on purpose; a call from another machine (over
a link, or from a hosted pane) that passes env is refused with forbidden,
because its variables describe that machine. The variables go to the process
only: they are not logged, not saved, and a pane a restore brings back starts
with the daemon's environment. The TUIOS_ variables and TERM are set after
them, so they cannot be overridden.
Each entry of sessions gains agent (the harness id, empty for a program no
manifest knows) and command (the argv as one line). The top-level agent,
command and prompt are the first session's. warning is as for
new-worktree, said once for the fan.
Request:
{"verb": "fan", "params": {"count": 3, "agent": "claude", "prompt": "Add a retry to the client.", "repo": "/src/api"}}Response:
{"result": {"type": "fan_started", "group": "fan/add-retry-client", "repo": "api", "agent": "claude-code",
"command": "claude", "prompt": "Add a retry to the client.", "total": 3, "sessions": [
{"session": "api-fan-add-retry-client", "branch": "fan/add-retry-client", "path": "...", "window_id": "..."},
{"session": "api-fan-add-retry-client-2", "branch": "fan/add-retry-client-2", "path": "...", "window_id": "..."},
{"session": "api-fan-add-retry-client-3", "branch": "fan/add-retry-client-3", "path": "...", "window_id": "..."}]}}ship-commit
Stage every change in a pane's git work tree, untracked files included and
ignored ones not, and commit it on the branch checked out there. The pane is
found as for review-diff. A call from inside a pane that names neither
session nor window is about the caller's own pane. git runs in the daemon
with the daemon's environment, which is the person's: their identity, signing
setup and hooks. The daemon sets no identity and adds nothing to the message.
When the commit fails, the index is put back as it was.
Params: session, window, message, force. Without message, the
message is the pane's last prompt or the line its last turn ended with. With
neither, the call is invalid_params. While the agent is working or
needs_input the call is not_ready, unless force. Errors:
nothing_to_commit, git_failed, not_worktree (a detached HEAD).
{"verb": "ship-commit", "params": {"session": "api-feat-retry", "message": "Add a retry to the client"}}{"result": {"type": "ship_committed", "session": "api-feat-retry", "window": "4be1c09a-...",
"worktree": "/home/u/.local/share/tuios/worktrees/api/feat-retry", "branch": "feat/retry",
"commit": "9f2c...", "message": "Add a retry to the client"}}ship-merge
Merge a worktree pane's branch into its base, in the repository's main
checkout. The base is into, else the base the worktree was made from when
that is a local branch, else the branch the main checkout is on. The main
checkout must have that branch checked out, no uncommitted change to a
tracked file, and no merge or rebase in progress (checkout_dirty). A merge
that conflicts is undone with git reset --merge and fails with
merge_conflict, with the files in the hint's available. Uncommitted
changes in the worktree are not merged: uncommitted counts them. A pane in
the main checkout is not_worktree.
Params: session, window, into, mode and message. mode is
merge, the default, which fast-forwards when it can, squash or ff-only.
message is the message of a merge or squash commit.
{"verb": "ship-merge", "params": {"session": "api-feat-retry", "mode": "squash"}}{"result": {"type": "ship_merged", "session": "api-feat-retry", "window": "4be1c09a-...",
"worktree": "/home/u/.local/share/tuios/worktrees/api/feat-retry", "repo_root": "/src/api",
"branch": "feat/retry", "into": "main", "mode": "squash", "before": "1a2b...", "after": "3c4d...",
"commits": 2, "fast_forward": false, "up_to_date": false, "uncommitted": 0}}ship-commit and ship-merge write files a pane's agent works on, so a pane
without admin needs write, and may name only a pane that holds nothing it
does not. Over a link they need write.
ship-push and ship-pr
ship-push pushes a pane's branch to a remote and sets it as the branch's
upstream: the remote the branch follows, else the only one, else origin,
or remote. It never forces. ship-pr pushes the same way, then opens a
pull request with the person's own gh CLI (gh pr create --head BRANCH [--base BASE] (--title T --body B | --fill) [--draft]), and reads it back
with gh pr view BRANCH --json state,statusCheckRollup,url,number. When the
branch already has an open pull request, none is opened. The daemon holds no
GitHub token.
Both send work off this machine, so neither sends anything on a first call.
It answers confirm_required: the hint's available lists what would be
sent (the branch, its commit and the remote, the commits, and for ship-pr
the pull request), and confirm carries a token. The token is a hash of the
branch, its commit, the remote and its URL, and the pull request's base,
title, body and draft flag. Call again with confirm set to it. A token for
anything else is refused again with the new token.
A caller the daemon cannot count as the person also needs the person's yes:
a process inside a pane, any connection limited with restrict-connection, and
a link, which is refused outright. The daemon puts the question in the Inbox
as the caller's pane, with the answers allow and deny, and waits wait
milliseconds (default 120000, at most an hour). When the wait ends first, the
call fails with not_ready and the hint names the request_id. Call again
with the same confirm and that request_id to wait on. A deny, or a
question dismissed, is forbidden.
Params: session, window, remote, confirm, request_id, wait, and
for ship-pr base, title, body (needs title), draft. Errors:
confirm_required, no_remote, nothing_to_commit (a branch with no
commit), gh_unavailable, git_failed, command_failed (gh failed after
the push), not_ready, forbidden.
{"verb": "ship-pr", "params": {"session": "api-feat-retry", "draft": true, "confirm": "5e0b8c1d2f3a4b6c"}}{"result": {"type": "ship_pr", "session": "api-feat-retry", "window": "4be1c09a-...", "branch": "feat/retry",
"commit": "9f2c...", "remote": "origin", "created": true,
"pr": {"number": 12, "url": "https://github.com/o/api/pull/12", "state": "open", "checks": "pending",
"passed": 1, "pending": 1, "branch": "feat/retry", "checked_at": 1791105577561633000}}}The pull request is recorded on the session's worktree record as pr. Over
a link both verbs need write, and are then refused by the handler.
ship-status
The pull request of a pane's branch as the daemon last read it, and with
refresh as gh says now. gh says whether the gh CLI is installed. pr is
null when the daemon knows of none. A refresh that finds none clears the
record, and one that finds one records it.
While a client is attached and a recorded pull request is open, the daemon reads each open one again every minute, one gh call at a time, and writes the record only when it changed. With none open, with no client, or without gh, nothing runs.
{"verb": "ship-status", "params": {"session": "api-feat-retry", "refresh": true}}A pane without admin needs read. Over a link it needs list.
compare-fan
The attempts of a fan side by side: one row per session of the fan, in the
order fan made them. Name any session of the fan; a worktree session that is
not part of a fan is invalid_params, with the fan sessions the caller
reaches in the hint (a pane without admin sees none outside its own reach),
and a session that is not a worktree is not_worktree.
Params: session, changes (default true: count each attempt's changes,
which runs a few git calls per sibling: the merge base, a snapshot of the
working state, the diff, the ahead count and git status. All of one
sibling's calls together are bounded at 10 seconds, and a sibling that passes
it reports the row without counts, with note saying so).
Each row carries session, branch, path, agent (as the fan named it),
harness, state (rolled up over the session's windows), prompt_status,
and:
-
files,added,removed: what the attempt changed against its base, committed and uncommitted work together, untracked files included and ignored files left out. The working state is read through a temporary index that starts as a copy of the worktree's own, so git's stat cache holds and the worktree's own index and files are not touched. The counts run frombase_sha: the merge base of the attempt'sHEADand the fan'sbase, or for a fan made fromHEAD, of the attempt'sHEADand the main checkout'sHEAD. Counting from the merge base rather than the base's tip means a base that moves on (a fetch, or another attempt merged into it) does not change a row. When no merge base resolves, the counts run from the base's tip andbase_shais omitted.aheadcounts the attempt's commits pastbase_sha, anddirtysays whether it holds uncommitted work. All are omitted withchangesfalse, and when git could not count, in which casenotesays why. -
verify: the lastverify-fancheck, as the worktree record holds it. -
last_command: the newest command a shell in the session finished, from its OSC 133 marks:cmdline,exit(omitted when the shell sent none),at(unix nanoseconds) andwindow. Omitted when no shell has marked one. An agent's own tool runs do not show here, which is whatverify-fanis for. -
gonewhen the worktree directory no longer exists. -
cost: the cost the attempt's agent reported withset-agent-meta, when it did.started_at: when its prompt was typed.done_at: when its agent last finished a turn. Both are unix nanoseconds, omitted when unknown. -
notes: the judge's notes on this attempt, fromset-fan-verdict. -
With
detail,file_list(at most 8 files, most changed first:path,added,removed) andlines(the first 6 changed lines:op,line,text, the text at most 200 bytes). Two more git calls per sibling, in the same 10 seconds. -
With
detail, alsoignored(at most 200 entries, a folder git ignores whole being one) andignored_count: the files git ignores in the worktree, whichkeep-fandeletes with it and git stash does not keep.ignored_errorsays why they could not be listed.ignored_hashnames the list forkeep-fan.
The result also carries prompt, the task the fan gave, and verdict when a
judge reported one: pick, summary, reasons, by, judge and at.
A pane without admin, or a connection restricted to its own session, gets
rows only for the sessions it could name itself: its own session, its fan
group, and the sessions a fan run from it started. Over a link it needs list,
because it returns counts and states, not file contents.
{"verb": "compare-fan", "params": {"session": "api-fan-retry"}}{"result": {"type": "fan_compare", "group": "fan/retry", "repo": "api", "repo_root": "/src/api",
"base": "main", "total": 2, "rows": [
{"session": "api-fan-retry", "branch": "fan/retry", "agent": "claude", "harness": "claude-code",
"state": "done", "files": 4, "added": 120, "removed": 31, "ahead": 2, "dirty": true,
"prompt_status": "sent", "verify": {"command": "go test ./...", "state": "passed", "exit": 0,
"started_at": 1790000000000000000, "finished_at": 1790000012000000000}},
{"session": "api-fan-retry-2", "branch": "fan/retry-2", "agent": "codex", "harness": "codex",
"state": "working", "files": 2, "added": 40, "removed": 3, "ahead": 0, "dirty": true,
"prompt_status": "sent", "last_command": {"cmdline": "make lint", "exit": 1, "at": 1790000030000000000, "window": "9c2e..."}}]}}verify-fan
Run one check in every attempt of a fan. Each session of the fan the caller
reaches gets a window named verify, in its worktree, running the command
with sh -c (cmd.exe /c on Windows). The call returns once the windows are
open; each result lands in the session's worktree record as verify, which
reaches clients with the ordinary state push and which compare-fan reports.
- The command is always the caller's, at most 4096 bytes. tuios never reads a
check from the repository, so cloning a repository cannot make
fanrun its code. - The window holds the grants
none, whatever the default is, so the check cannot call tuios. - The check's exit status reaches the daemon on a pipe the check itself does not inherit, so nothing it prints can pass for its status. A check that passes closes its window. One that fails keeps it open, with the output, and says so; enter closes it. On Windows the window closes either way.
timeout_msfails a check that runs longer and closes its window; the record'snotesays it timed out. Without it a check runs until it ends.- A check still running in a session is stopped, and its window closed, before the new one starts. So is the window a failed check left open, so running a check again does not pile up windows waiting for enter.
- A session whose worktree directory is gone is skipped, and
skippedsays so. When nothing could be started the call isinternal, with the reasons in the hint. envadds variables for the check, with the rules offan'senv. The tuios CLI sends itsPATH.
A pane needs the fan grant, and reaches its own fan group; the checks start
only in the sessions it reaches. Over a link it needs open and write.
Params: session, command (required), timeout_ms, env.
{"verb": "verify-fan", "params": {"session": "api-fan-retry", "command": "go test ./...", "timeout_ms": 600000}}{"result": {"type": "fan_verify_started", "group": "fan/retry", "command": "go test ./...",
"sessions": ["api-fan-retry", "api-fan-retry-2"]}}The record while it runs and once it ends:
{"command": "go test ./...", "state": "running", "started_at": 1790000000000000000}
{"command": "go test ./...", "state": "failed", "exit": 1, "started_at": 1790000000000000000, "finished_at": 1790000042000000000}keep-fan
Keep one attempt of a fan and remove the others. Each sibling is removed the
way remove-worktree removes it, each on its own: a sibling with uncommitted
changes is left in place, with worktree_dirty, unless stash or force
says what to do with them, and the others still go. Branches are never
deleted. A check running in a removed sibling is stopped. A session that is
not part of a fan is invalid_params.
Only the person or a caller with admin may call it: a pane without admin
and any restricted connection are refused. Over a link it needs write.
Files git ignores (.env, build output) are deleted with a worktree and are
not stashed. compare-fan with detail lists them. group, repo_root and
fan_id, when given, name the fan the caller read: a session that is no
longer an attempt of it, after a rename, is invalid_params and nothing is
removed.
siblings and ignored name what the caller showed: the attempts to remove,
and for each the ignored_hash compare-fan gave for its ignored files. When
the other attempts differ, or one's ignored files changed in any way, the
keep is refused whole.
Params: session (required), stash, force, merge, merge_mode,
into. With merge, the kept attempt's branch is first merged into its
base, as ship-merge does, with merge_mode and into as its
mode and into. The result then carries merge. A merge that conflicts or
is refused fails the call before any sibling is removed.
{"verb": "keep-fan", "params": {"session": "api-fan-retry-2"}}{"result": {"type": "fan_kept", "kept": "api-fan-retry-2", "branch": "fan/retry-2", "group": "fan/retry",
"repo": "api", "left": 1, "removed": [
{"session": "api-fan-retry", "removed": true, "branch": "fan/retry", "path": "/home/u/.local/share/tuios/worktrees/api/fan-retry",
"changes": 0, "stashed": false, "discarded": false, "session_killed": true, "branch_kept": true},
{"session": "api-fan-retry-3", "removed": false, "code": "worktree_dirty",
"note": "/home/u/.local/share/tuios/worktrees/api/fan-retry-3 holds 1 uncommitted change. Nothing was removed."}]}}bundle-worktree
Read a worktree session's work out in chunks, so it can cross a link that caps
a reply line at 16 MB. tuios worktree pull is the caller. The transfer is the
branch's commits as a git bundle, then the uncommitted work, untracked files
included, as a binary patch against HEAD. The patch is read through a
temporary index, so the worktree's own index is not touched.
The first call names session and makes the transfer. Without full, the
bundle holds only the commits past the merge base of HEAD and the worktree's
base, and the reader must have base_commit. With full, or when the base
is not known, it holds the whole branch. A branch with nothing past the base
has no bundle (bundle_bytes: 0). The reply carries token, repo,
origin_url, branch, base, base_commit, head, full,
bundle_bytes, patch_bytes, changes (paths the patch touches), size,
sha256 of the whole transfer, and the first chunk.
branch and head are what the worktree's HEAD is on when the call runs, not
the branch the session was made on. An agent that made its own branch in the
worktree has that branch carried. A detached HEAD is refused with
not_worktree, since there is no branch to carry. HEAD is read again once the
bundle and the patch are written, and if it moved in between, from a commit or
a branch switch, the call answers git_failed and nothing is kept. Try again.
The bundled branch always ends at head, and the patch is made against it.
Every reply carries a chunk: content (base64, at most 4 MB before encoding),
offset, next and done. Later calls pass token and offset set to the
previous next. release with token ends a transfer early.
A transfer is readable only by the connection that made it. It ends after its
last chunk, on release, when that connection closes, or after ten minutes
unread, and its files are removed each time. At most four are open on one
daemon, and past that the call is rate_limited. A transfer is capped at
512 MB.
Request:
{"verb": "bundle-worktree", "params": {"session": "api-fan-add-retry-2"}}
{"verb": "bundle-worktree", "params": {"token": "3f...", "offset": 4194304}}Response to the first call:
{"result": {"type": "worktree_bundle", "session": "api-fan-add-retry-2", "token": "3f...", "repo": "api",
"origin_url": "git@github.com:acme/api.git", "branch": "fan/add-retry-2", "base": "main",
"base_commit": "9c1e...", "head": "b07a...", "full": false, "bundle_bytes": 2310, "patch_bytes": 812,
"changes": 2, "size": 3122, "sha256": "...", "content": "...", "offset": 0, "next": 3122, "done": true}}What a caller on another machine can do with these
start-agent, fan and new-worktree with repo_url or clone, and
bundle-worktree, grant a caller on a link or in a pane nothing it could not
already do with new-window and a command: start a program in a directory of
this machine, or read files there. Over a link they are held to the per-host
link policy (What a linked machine may do here):
start-agent, fan and new-worktree need open, and a clone checks open
again at the point it would run. bundle-worktree needs write, since it
reads a worktree's files, and write already lets a machine type into a shell
here and read any of them. What they add on their own is bounded: a clone
fetches only network URLs, the search reads only .git/config files under the
roots named above, and a transfer is only readable by the connection that made
it.
Verbs: The Inbox, the queue and review
Verbs: The Inbox, the queue and review: part of the Control Protocol of TUIOS.
Verbs: Other machines
Verbs: Other machines: part of the Control Protocol of TUIOS.
tuios lives only at tuios.dev and github.com/Gaurav-Gosain/tuios. tuios has no X or Twitter account. An account that offers a tuios token or presale is not this project.