Skip to main content
A task is one change you want: fix a problem, add a feature, or improve a page. Describe the result in your AI chat. The agent works out the steps and keeps the notes it needs to continue later.
Send to your agent
Give an example of a correct result. “Export the rows I can see” is easier to check than “make exports better.” If the task is large, ask the agent to break it into smaller parts.

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 then reads the issue from the start of each new task’s id and keeps it with the task: 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.
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.
Durable knowledge the task produces goes to .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 runs jig 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.
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:
It needs no class and no review of its own, and it is listed as finished, not abandoned. Something the project’s knowledge should now say is not left as a finding: the agent writes it down before the commit. A P0 or P1 stops the task from being finished. Until it is resolved, the agent cannot mark the task ready, record what the project should remember, or commit and open the pull request (Letting the agent ship). A fix alone does not resolve it: the agent fixes the problem, and a second review confirms the fix and closes the finding. The other way out is to decide the problem does not need fixing — the review was wrong, or you accept it. For a P0 or P1 that decision is yours: the agent shows you the finding and asks, and writes your answer down with it. A P2 or P3 the agent may set aside on its own, with a reason. To see where a task stands, ask “what did the review find?”, or run:
jig status marks a task that is stopped this way with blocking=<n>.

When the change moved after review

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.
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. 0 lets 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, consolidate or ship) and JIG_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, and git ls-files --others --exclude-standard for 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 status names it before anyone reaches the gate.
  • It is the team’s rule. Jig reads these keys from .ai/config.yaml only; set in your own config.local.yaml they are ignored, and jig status says so.
When a hook is wrong for one task — it misreads the change, a tool it needs is missing here, its path was renamed — a person can let that one task through, with a reason:
  • 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 status names the waiver under the task and lists the task with what needs you; the status page marks it; jig task ship adds a Hook 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 waive refuses 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.
A hook guards the way a task is finished with Jig, not the repository: CI does not run it, and it reads the script from the task’s own tree, so a change to the script is part of what review reads. A script that never ends holds the task: keep hooks quick, and away from the network and from anything that asks a question.

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 installed node_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:
Every line starting with !! 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 ignored packages/, 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.
The worktree then gets a real 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 with carry. 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’s packages/ 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.
If 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’s task.md:
The part before # 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:
The agent records reading them like knowledge, so when someone edits that design later, the line says 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:
Or, when a task already running finds out that it needs them:
The task remembers it, so every later 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. A vendor/ 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:
What to know about it:
  • It runs on this machine, in the worktree’s folder, with sh -c and nothing on its input. Never through run.exec: that setting is personal, and this line is the project’s. If your project lives in a container, the command reaches it itself — a make target can read the container’s name from a personal file that worktree.carry brings 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; and JIG_DANGLING, one per line, the links inside carried paths that lead nowhere in this worktree. That last one is the dev:link case: Composer treats such a package as installed and leaves it alone, so remove those links before composer 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 in JIG_DANGLING and runs composer install, so the task runs on the lock’s versions; with packages in 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) in jig status, a setup: line in jig task route — until a jig task bootstrap succeeds.
  • Files it leaves that Git can see are named, not removed: a worktree holding them can never be cleaned up, so add them to .gitignore or have the command not make them.
Once a project has a 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 shows what needs your answer, which tasks are running, and how far the project’s plans have progressed. Start with Needs you; each card tells you what to do next.
The page refreshes as Jig records changes. If it labels information as stale, ask the agent to refresh the status before relying on it.
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:
  1. 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.
  2. 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 status at a terminal groups its Tasks section the same way. Paused tasks are folded away below.
  3. 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.
  4. Details. The counts at a glance, and the complete jig status text, folded away at the bottom.
Why some data is marked stale. Whether a pull request is open or merged comes from housekeeping, which asks GitHub or GitLab once a day when an agent session starts. When its last run is older than that, or GitHub/GitLab did not answer, the page says stale; run 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.
A pull request was open at the last housekeeping run goes too when you close its task after that run: a task with a pull request closes only once GitHub or GitLab says it merged. When GitHub or GitLab cannot be asked — 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.