Send to your agent
Talking about tasks
You do not need commands; these are the kinds of things you say:Tasks from a tracker
If your project keeps its tasks in a tracker — YouTrack, Jira, Linear, GitHub or GitLab issues — start a task’s id with the issue it belongs to:SRD-2455-fix-login, or 123-fix-login. Tell Jig
what an issue looks like in .ai/config.yaml:
.ai/config.yaml
jig task list and jig status show issue=SRD-2455, and jig task show its issue: line. When the agent ships the
task, the issue goes into the commit’s first line and the pull request’s title — SRD-2455 Fix the login form, or Fix the login form (#123) for a numbered issue — which is where a tracker’s Git
integration looks for it. A title that already names the issue is left as it is.
Without the setting no issue is read from any id, so a task called release-0-25-1 never becomes
issue release-0. A task filed before you added it keeps no issue. To have the agent create the
issue first and name the task after it, write that down as a rule in your project’s AGENTS.md.
What to do when the agent needs you
Continuing tomorrow? Open the same project and name the task: “Continue the CSV export.”
If several tasks match, choose the one you mean. The task’s notes help the agent pick up the work.
For developers: branches and task workspaces
For developers: branches and task workspaces
When the agent starts a task it creates:
- a branch of its own, cut from your main branch — or from an epic branch, when the task belongs to a specification that is released at once (New project);
- a workspace in
.ai/workspace/tasks/<id>/— the task description, analysis, plan or design, whatever its route needs. Workspaces are local to your machine and never committed: they are notes for the people and agents working on the task, not documentation.
.ai/knowledge/ and is committed with the code.Small work — a typo, a one-file fix that fits in one session — needs no workspace at all.A task’s states
Paused is a mark on an active or ready task, not a state of its own: it says the work was
set aside, with a reason, and it comes back where it was.
Parked is what a shipped task is in a project on the staging flow while it waits at the staging
branch: for a colleague’s review of its pull request (
review), or, once it is on the staging
branch, for “prepare for prod” (signal). Nobody sets it: Jig reads it from git and from what the
forge last said, every time. A parked task is not your current task, the queue does not offer it,
and you can start another task in the same checkout. When QA or a reviewer asks for a fix, say so
— “QA found a bug in booking-form, fix it” — and the agent runs jig task resume <id>: the task
is active again, and stays out of parking through the fix and its verify until the next
jig task ship — whatever your agent.git, also when the ship hands the commit or the push to you.
After the ship it is parked again as soon as Jig sees a reason: at once while its new pull request into
the staging branch waits, or, when your CI lands tasks itself (git.staging_land: external), only
once a fetch shows its work on the staging branch.
How a task ends
Every task ends with the question what should the project remember? — a new decision record, an updated rule, or explicitly nothing. The agent records that answer before the commit, so the knowledge travels in the same pull request as the code. A merge alone does not close a task: a fix can still follow it. At the start of a session the agent checks which of your tasks were merged, names each one and asks whether it can be closed. Nothing is closed without your yes.Giving a task up, or moving it elsewhere
Tell the agent why, and it runsjig task abandon <id> --reason "<why>". When the work belongs to
another repository — a neighbouring package, say — it adds --moved-to <repo>#<task-id> (the same
form as a Linked: line, a path from your main checkout, or <repo>#spec/<spec-id>). When that task
is not there yet, it prints the command that files it there — for a spec, it says to add the item
yourself; Jig never writes to the other repository.
The reason goes where the next agent reads it. If the task came from a spec’s roadmap, the item that
named it is closed in place — checked, with — moved to … (<date>): <why> or — dropped (<date>): <why> at its end — so nobody starts the work here again because the plan still said so. A task from
a spec cannot be abandoned without a reason. Jig never edits the roadmap on your main branch: for a
spec built on an epic the item is rewritten in a checkout of the epic, and you commit it there; for any
other spec Jig switches to the spec’s own branch, spec/<spec-id> — as jig spec resume does — makes
the edit and commits it there, and jig spec ship <spec-id> sends it on. (If your agent may not commit,
the edit waits on that branch for your commit.) Anywhere else — on the task’s own branch, say — the item
is left alone and Jig prints where to run jig spec drop <id>. In a roadmap phase run the coordinator
runs it, after the merge.
How finished task notes are cleaned up
How finished task notes are cleaned up
What is left behind is cleaned up automatically. The workspace of a closed task is moved to a trash
folder, and deleted from there after a week; so is the workspace of a task closed without ever being
started, such as a findings task closed by decision once its source task’s workspace is gone. A task whose remote state cannot be determined keeps its
workspace. An abandoned task, and one nobody touched for two months, is archived instead of deleted: its notes stay
where they were, the task leaves your lists, and
jig task list --status archived shows it and
jig task unarchive <id> brings it back, without its place in the queue (jig queue set gives it one again). You can archive a task yourself with jig task archive <id>. The trigger is a Claude Code session hook
or a scheduler you choose (Configuration).Review findings
A review is never done by the agent that wrote the change: it goes to a helper that has not seen the work being done, and a repeat review goes to a new one (Concepts). When a task is reviewed, each problem the review finds is written down in the task’s workspace with a severity:
A code smell the review notes — duplicated code, say, or an option nothing uses — is a P3, a P2 at
most, and never stops the task.
A P3 is never fixed after the review: it stays open and is listed in the pull request, so a nit does
not cost another review round. If you want one fixed, ask — it is then an ordinary edit followed by a
re-review.
Small findings left open do not get lost when the pull request is merged — by you, or by an agent
allowed to merge. When the agent opens the pull request — or, with
git.staging_land: external, when it pushes the branch your CI lands, with no pull request — Jig files one task, <task-id>-findings,
holding every open P2 and P3 word for word with a link to the pull request. It is not started and
not in the queue, so no agent takes it on its own: it waits for you to go through the findings —
file a task for one, or set it aside with a reason. Shipping the same task again files no second
one. When every finding is decided, close it as done:
jig status marks a task that is stopped this way with blocking=<n>.
When the change moved after review
For developers: review receipts and stale reviews
For developers: review receipts and stale reviews
A review ends by pinning what it read: the task’s own change, the project knowledge that applies to
it, the approved design and the list of findings. If any of them changes afterwards — a line of the
task’s code edited, a convention the review relied on rewritten, a finding closed by the agent that
wrote the code — the review no longer describes the change, and the task stops again for the same
three steps until the change is reviewed once more. Committing the reviewed change does not count as
a change; only its content does, and neither does merging the main branch into the task when that
brings nothing the task touches. The knowledge the task writes itself and the specification files are
not pinned: the agent writes them after the review, as the last step of every task.A task of the highest risk class (T4) cannot be finished without such a pinned review at all.The repeat review after a fix does not start from zero. A new helper reads only what changed since
the review — the difference between the reviewed state and now — and checks each fixed finding against
the new code. It reads everything again when it cannot trust the earlier review as a starting point:
the approved design or the project knowledge changed, the review was written before this was
possible, or the reviewed state is no longer available. The check is still the same afterwards: any
change makes the review stale, and the repeat review writes a new one.To see whether the review still holds, ask “is the review still current?”, or run
jig task receipt <task-id> --check. jig status marks a task whose review no longer holds with
review=stale. It does not resolve the knowledge the review read, so for a review that still matches it says
not checked, not current; --check and shipping do the full check.When a stage was skipped
A task’s class names the stages it goes through, and the stages that leave a record must have left it before the task can be marked done, recorded as consolidated, or shipped: your approval of the design for T3 and T4, the review (or the architecture review) for T2 and up, and the agent’s own verification for every class. When one is missing, Jig refuses and names it, with the command that records it — the agent goes back to that stage instead of working around it. A lighter route trims none of these.For developers: what counts as the record
For developers: what counts as the record
jig task set <id> status ready asks for every record before verification: design.md and an
approval (jig task gate) that still matches it, for T4 also spec.md and alternatives.md, and a
review receipt for the review stage the route names (jig task receipt <id> --stage review or
--stage architecture-review; the receipt remembers every stage it was written for).
knowledge_consolidated true and jig task ship also ask for status ready, verification’s own
sign-off. Discovery, analysis and the plan are prose the agent writes for itself, so no file is asked
for them. A task filed before this check existed is not refused: the same list is printed as a
warning, and the task finishes under the rules it started with.Your own checks at the finish
Jig’s checks know nothing of your project’s rules — that a change to the public API updates the published docs, say. Name a script of your project at one of the three points where a task is finished, and Jig runs it there:hooks.ready runs when a task is marked ready (jig task set <id> status ready),
hooks.consolidate when its knowledge decision is recorded
(jig task set <id> knowledge_consolidated true), and hooks.ship when it is shipped
(jig task ship), before anything is committed or sent. Each runs after Jig’s own checks — open
findings, the review, the route — have passed.
- The exit code decides.
0lets the task through, and anything the script printed is shown as a warning. Any other code stops it: Jig names the script and shows what it printed, and nothing is recorded, committed or sent. Every script of a list runs, so one attempt shows every refusal. - It runs in the task’s folder — its worktree, when it has one — on this machine, with nothing
on its input, and is told
JIG_TASK_ID,JIG_TASK_DIR(the task’s workspace),JIG_GATE(ready,consolidateorship) andJIG_BASE, the branch the task lands on as Jig judges it (refs/remotes/origin/<base>when origin has it). Which files the task changed is the script’s to work out:git diff --name-only "$(git merge-base "$JIG_BASE" HEAD)"for what is committed or edited, andgit ls-files --others --exclude-standardfor new files nobody has added yet — at these gates the change is often not committed. Prefer what the diff shows to what a task’s notes claim: an agent can write any note. - It only checks. A hook that changes anything Git can see in the task’s folder — a formatter rewriting a file, a log left behind — stops the gate, so that nothing reaches a commit unreviewed.
- It is run by its path when it is executable, so its first line chooses the language, and as
bash <path>when it is not — a checkout on Windows can lose the executable bit. - A path that is not there stops the task too, as does an absolute one or one that leads out of
the project.
jig statusnames it before anyone reaches the gate. - It is the team’s rule. Jig reads these keys from
.ai/config.yamlonly; set in your ownconfig.local.yamlthey are ignored, andjig statussays so.
- One hook, one gate, one task. The same script at another gate, and every other script of the
gate, still stop the task. The path must be one the gate names in
.ai/config.yaml. - The hook still runs. Its refusal is shown as a warning with your reason and what it printed, so you see whether it still objects. A path that is not there can be waived the same way.
- A hook that changed files still stops the task: a waiver sets aside the script’s verdict, not the check that nothing reaches a commit unreviewed.
- It is never quiet.
jig statusnames the waiver under the task and lists the task with what needs you; the status page marks it;jig task shipadds aHook waivers:block to the commit and to the pull request, so the reviewer reads it with the change. - Take it back with
jig task waive <id> <gate> <path> --withdraw; running it again with a new reason replaces the old one. - Autopilot never waives.
jig task waiverefuses while the task’s autopilot run is on. A refusal the agent cannot fix by changing the work is one of its stops: it asks you for a waiver, or, unattended, stops and opens a draft that names the hook. Waive it, then resume the run.
Several agents at once
One checkout holds one piece of uncommitted work. When an agent is already working and you want to start something else, say “start the caching task in a separate worktree”. The agent creates a second working copy of the repository next to it (in../<project>.worktrees/<id> by default), cut
from the freshest main branch, and leaves the current work alone. Open a new agent session in that
folder — the agent tells you the path; some runtimes can switch there on their own. Where the
runtime can open a session for you (the Claude Code desktop app can), the agent starts it in that
folder as soon as you ask, so you can open it and watch or talk to it. Ask in the same message:
the app lets an agent start a session only on your own words, not later on its own.
A worktree is a Git checkout, so it starts with exactly what Git tracks — no vendor/,
node_modules/ or .env, since every project with an install step keeps those out of Git.
Starting a task with --worktree carries that state across for you: your project’s
verification profiles declare what their stack needs
(PHP’s vendor, Node’s node_modules, Laravel’s .env), and the project can add its own with
worktree.carry in .ai/config.yaml. It
copies what each worktree must have its own of. Never carry a folder of separate Git repositories
you edit — a copy is a second clone, and its commits go when the worktree goes; share it instead,
as described below.
A carry copies what this checkout has, not what your lock file says. Usually they are the same.
They are not when this checkout runs a local development setup: after composer dev:link, say,
vendor/acme/* are links into packages/, and the copy keeps them — leading nowhere in a worktree
that does not share packages/, or to whatever your package checkouts hold right now in one that
does. A project like that brings its worktrees back to the lock with
its own command.
Jig only carries what your project keeps out of Git, and it checks rather than assumes: after
placing something it asks Git what it now sees in the worktree, and takes straight back out
anything Git noticed, telling you to add that path to .gitignore first. The reason is narrow but
absolute — a worktree holding anything Git can see cannot be removed afterwards, so Jig would be
leaving you a folder to delete by hand.
Carrying is never required to succeed — if the owning checkout has nothing to carry either, Jig
says so and names the install command to run yourself, rather than installing anything over the
network. Run jig task bootstrap <id> to try again once you have, or start with --no-bootstrap
to skip the carry for that run.
An autopilot run of a whole roadmap phase does this for you:
it puts every task of a wave in its own worktree and gives each one its own agent.
Each worktree has its own branch and its own uncommitted changes, but they all share one task
list: the notes, plans and designs of every task live in the checkout you filed them in, and a
worktree reaches the whole folder across. So the original checkout shows every task and where it
runs, an agent in a worktree can look up a task somebody filed elsewhere, and a task the agent
files from inside a worktree lands with all the others instead of vanishing when that worktree is
removed. The agent writes through Jig rather than by hand, so the task’s date and the status page
keep up wherever it works. Review and commit in the worktree as you would
anywhere. When the task is closed and its change has landed on its base — an epic branch included —
the worktree is removed, but only if it has no uncommitted changes and no lock. Worktrees you or your
agent created by hand are never removed.
What a removed worktree takes with it
Git refuses to remove a worktree that holds changes it tracks or files it has never seen. The files your project ignores are the exception: it deletes those without a word. Jig adds one refusal of its own there. If an ignored folder holds a separate Git repository with work that is nowhere else — not committed, or committed and on no remote — the worktree stays, and the task is listed under “needs you” with the path, so you can go and push it. That covers the expensive case, a repository you cloned or started inside a worktree whose commits exist only there. An installednode_modules or a dependency pinned to a tag holds nothing back; if it did, a project
that installs anything would never be cleaned up at all.
Everything else your project ignores still goes — a .env, a local database, files you
generated by hand. This is not an oversight waiting to be fixed: nothing in a file says whether it
can be made again, and no rule can tell your .env from a folder your build wrote. What Jig does
instead is stop being silent about it. The line that records the removal in
.ai/runtime/housekeeping.log names the ignored paths that went with the worktree, so afterwards
the question “what was in there” has an answer. The log keeps the decisions of its last ten runs (and the
record of every purged task for good), so look there soon rather than months later.
So the rule for you is short: do not leave in a worktree the only copy of something git does not
have. To see in advance what one would lose, ask git inside it:
!! is ignored, and ignored is what gets deleted. Copy out what you want
to keep, and push from inside any repository of its own. Running git worktree remove yourself is
exactly as dangerous as it always was — that half belongs to git, and no setting in Jig changes it.
Sharing a folder of packages you edit
Some projects keep, next to their own code, a folder of separate Git repositories they edit as they go — Composer path repositories under an ignoredpackages/, say. Each package has one
checkout, and an edit made from any worktree has to land in it. Copying is the wrong tool for
that: a copy gives the worktree a second clone of every package, work done there is invisible to
the checkout beside it, and git worktree remove deletes an ignored folder without a word,
commits included.
Declare such a folder as shared instead — for every task, as below, or only for the tasks that
edit it, as the next section shows. You do not have to spot it yourself:
when a folder that Git ignores holds separate repositories and nothing shares it, jig status and
jig task start --worktree name it and both ways to share it.
packages/ folder in which every entry is a link to the package in
your main checkout (on Windows without symbolic links, a junction). There is one copy of each
package, so a commit made from any worktree is in it at once, and removing the worktree — by Jig’s
cleanup or by git worktree remove — removes the links and never the packages. A folder declared
both ways is shared, not copied.
Two things to know:
- The folder must be in
.gitignore, as withcarry. If Git can see the shared folder, Jig takes it back out and tells you to add it. - A package added later does not appear by itself. The worktree gets links to the packages
that existed when it was created. Run
jig task bootstrap <id>and the new ones are linked in; nothing that is already there is touched. A folder you create inside the worktree’spackages/is that worktree’s own, not shared — create new packages in the main checkout. - The links work inside a container. On macOS and Linux each link points to its package by a
relative path, so a container that mounts the folder holding both your checkout and its
worktrees — devilbox’s
/shared/httpd, say — finds the packages there as well as on your machine. A worktree made by an earlier Jig keeps its links by full path; a worktree made anew gets the new ones.
packages/ is tracked by your project’s Git, the worktree already has it and the declaration
does nothing.
A task that continues work in a neighbouring repository
When a task picks up where a task in one of those packages left off — its design, the contract it settled — say so in the task’stask.md:
# is the path from your main checkout to the other repository (.. is fine
for one beside it); after it comes a task id, or spec/ and a spec id. Each time the agent asks
which documents to read, the other task’s task.md, design.md and other notes — or the spec’s
spec.md and roadmap.md — come back on linked: lines with the link they came from:
changed since acknowledged and the agent has to read it again before implementing. A task’s
notes live only on the machine where it was filed: on another clone, or when the folder is not
there, the line says unreachable: and why. Jig only reads the other repository; it never writes
there, and the other task does not learn about yours. A finished review does not follow an edit
there: the review stays current, and the pull request can still be opened, even though the agent is
asked to read the changed document again.
Sharing for one task
Sharing for every task has a cost: each task then runs against whatever your package checkouts hold right now — their current branches, not the versions your lock file pins — and with every package that a local overlay adds. A task that only changes the project itself is better off without them. Share the folder only with the task that edits the packages:jig task bootstrap keeps the links and adds packages that
appeared since. The rules are those of worktree.share: the folder must be in .gitignore, and a
folder you create inside the worktree’s copy is that worktree’s own. Asking for a folder the
project already shares changes nothing. A share cannot be taken back from a running task.
Finishing a worktree with your own command
Some state cannot be copied right. Avendor/ built for a local development setup is the common
case: see the warning above. Name a command of your project, and Jig runs
it in every new worktree, after the share and the carry:
- It runs on this machine, in the worktree’s folder, with
sh -cand nothing on its input. Never throughrun.exec: that setting is personal, and this line is the project’s. If your project lives in a container, the command reaches it itself — amaketarget can read the container’s name from a personal file thatworktree.carrybrings along, since the carry has already happened when the command starts. - It is told what it needs in its environment:
JIG_TASK_ID;JIG_OWNER_CHECKOUT, the checkout the worktree was made from;JIG_SHARED, the folders shared with this worktree, separated by spaces; andJIG_DANGLING, one per line, the links inside carried paths that lead nowhere in this worktree. That last one is thedev:linkcase: Composer treats such a package as installed and leaves it alone, so remove those links beforecomposer install. Jig does not remove them itself — what a link is for is your project’s to know. - A typical command checks
JIG_SHARED: empty, it removes the links inJIG_DANGLINGand runscomposer install, so the task runs on the lock’s versions; withpackagesin it, it links the local packages the way your development setup does. - It runs again with every
jig task bootstrap, so write it to be safe to repeat. In a phase run it may run in several worktrees at the same time; Composer and npm caches handle that, and Jig does not take turns for it. - It is stopped after
worktree.setup_timeout, 10 minutes by default, together with every process it started on this machine — and so it is when Jig itself is interrupted. A process a container started inside itself may not hear that, and under Git Bash on Windows only the command’s own shell is sure to be stopped. - It is never fatal. If it fails or is stopped, the task is started anyway and Jig says how to
try again. The failure stays on the task —
setup=failed (exit 1)injig status, asetup:line injig task route— until ajig task bootstrapsucceeds. - Files it leaves that Git can see are named, not removed: a worktree holding them can never be
cleaned up, so add them to
.gitignoreor have the command not make them.
worktree.setup, jig status stops suggesting worktree.share — preparing
worktrees is then the project’s own business — and jig task start --worktree still names
--share for a task that edits the packages.
Seeing where things stand
jig status answers in the terminal. For a page you can keep open in your browser while the agent
works — or send to someone who does not use a terminal — ask the agent to “open the status page”,
or run:
The page refreshes as Jig records changes. If it labels information as stale, ask the agent
to refresh the status before relying on it.
For developers: status files, refresh behaviour, and all card types
For developers: status files, refresh behaviour, and all card types
It writes one file,
.ai/runtime/status.html in your project, prints its full path and opens it in
your browser. The same command works in Git Bash, in PowerShell and in the macOS or Linux terminal.
Where no browser can be opened — over SSH, for instance — the page is written anyway and the command
tells you where it is. jig status --html writes the page without opening it.The page keeps itself current. Once it exists, every time the agent changes a task — starts it,
records a review finding, reaches a new stage, stops to ask you something — Jig redraws the file, and
the open page reloads itself every 10 seconds. You do not need to run anything again; the time at the
top says when it was last drawn. A reload keeps your place — the scroll position and the sections
you opened — and waits while you scroll, click or select text. To read without interruption, press
Pause in the bottom-right corner; Resume brings the page up to date at once. The pause lasts
until you close the tab. It is drawn from the checkout the tasks were filed in, which shows
every task started there, including those the agent went on to work on in a separate worktree:
starting a task in a worktree keeps its workspace where it was filed and links it across. Those
redraws only refresh a page that is already there: until you run jig status --html or --open,
nothing is written, and deleting .ai/runtime/status.html ends them — nothing recreates the page
until you ask for it again.It answers four questions, in this order:-
Needs you. Each card says what happened and, in one line, what to do:
When there is nothing to do, it says Nothing needs you right now.
-
Running now. Every task in progress: its class, status, the branch it lands on, the worktree
it runs in, whether its review still holds (current, stale, or none yet — and whether a T4 task
still needs one), and each finding that stops it. For a task on autopilot it also shows the stage
it is in, for how long, and how many of its two fixing attempts it used. Tasks of a specification
are grouped under it — epics first, with how far the roadmap has got — and tasks of no
specification come last, under Other tasks;
jig statusat a terminal groups its Tasks section the same way. Paused tasks are folded away below. - Specifications. How far every roadmap has got, phase by phase. For a specification built on its own branch, the progress is read from that branch as your copy of it last saw it. An item whose task was closed here, or that the last housekeeping saw merged, counts as done even before its checkmark reaches that branch.
-
Details. The counts at a glance, and the complete
jig statustext, folded away at the bottom.
jig housekeeping to update it. A
pull request the agent opened itself appears at once, with its link. The knowledge counts come from
the last full jig status and show their time too.Which cards go on their own, and which wait for housekeeping. A card goes by itself when what
it asks for has been done and the page can see that in your own files. Three do:- Merged: the task can be closed — goes when the task is closed.
- The pull request was closed without merging — goes when the task is abandoned.
- A worktree was kept — goes when that worktree is no longer there.
gh or glab missing from the PATH, not signed in, an error, no answer in time —
the close is refused with the reason, and the pull request may well be merged already: run the same
close again once the forge answers.Every other card that came from housekeeping waits for the next run, because only GitHub or GitLab
can answer it and the page will not go to the network while you are working. The work landed on a
different branch than planned is one. So is A pull request was open at the last housekeeping
run for a task still open, abandoned, or already closed when that run looked.
Those cards are stamped with the time of the run they came from — a housekeeping time on a card
means it is a report, not a fresh look.One card is not removed but reworded. Abandoning a task never touches GitHub or GitLab, so its
pull request stays open; the page keeps showing it, and asks you to close it or reopen the task
instead of telling you to merge work you gave up on.To open the file by hand, double-click status.html in your file manager — on Windows, in File
Explorer, open your project folder, then .ai, then runtime; on macOS, Finder hides folders whose
name starts with a dot until you press Cmd+Shift+. (period). From a terminal:The page is a single file with nothing to download; its one small built-in script only reloads it
and keeps your place. It opens in any browser, offline, and follows your system’s light or dark
theme; with JavaScript turned off it still reloads every 10 seconds, without keeping your place. Nothing but the page and the counts it reuses is
written, both in
.ai/runtime/, and neither is ever committed.When the work turns out bigger
A task starts with a class the agent chose from the risk it saw. When the work turns out bigger — a “local fix” that touches an interface other parts depend on — the agent re-classifies it and runs the stages the new class requires, including your approval where the new route has a human gate. Risk sets the floor: a one-line change to authentication is never trivial. A class can go down too, when the work turns out smaller — but lowering it drops stages, so the agent has to say why. The reason is kept, and shown wherever the class is:jig task route <task-id>,
jig status (lowered=T3), the status page and the autopilot report in the pull request. A run
without stops never lowers a task below the classes that need your design approval.
Who commits
By default the agent does not commit: a finished task waits in your working tree, and you review the diff and commit it. One line in your own.ai/config.local.yaml — agent.git: pr — lets the agent
commit, push and open the pull request instead; only agent.git: merge also merges, once CI passed.
A merge refuses a commit that would leave changes in the tree unless --partial says they are not
the task’s.
Letting the agent ship explains the levels and what happens at the end of a task.