.ai/ layout or the installer.
Update the tool with jig self-update, then run jig upgrade in each project and commit the diff
(Install). Releases are tagged on
GitHub.
0.45.0 — 2026-11-13
A team that tests on a staging server can now have each task land on a staging branch, wait there while it is tested, and reach the main branch only when someone says “prepare for prod” — the task’s own tested commits, nobody else’s. Releases are made apart from feature work, and a release cannot go out with notes that miss what reached the main branch.jig refresh brings a clone up to origin
without touching your checkout.
- The staging flow. With
git.flow: staging, a task’s pull request goes into the staging branch, lands there after review (jig task land) and waits parked while it is tested. “Prepare for prod” (jig task promote, from your agent or from CI) then opens a pull request from the task’s own branch into the main branch, for exactly the commits that were tested.jig statusshows what is parked and where staging drifts from the main branch. The default staysdirect. Proven with stand-in remotes, not yet on a real team’s project or on GitLab (known issues). See Test on staging first. - A release is made apart from feature work. An epic’s final pull request now merges the
feature without touching the version. The release is its own last pull request, cut from the
freshest main branch, and records the commit its notes describe
(
jig task set <id> notes_through <sha>). Fromagent.git: pr,jig task shiprefuses a change that raises the version until it does, and while the main branch has commits after that one;jig spec shiprefuses a feature epic (noRelease:line) whose final pull request raises the version. This release is the first one made this way. See Specs and epics and Upgrading. jig refreshbrings the clone up to origin. It fetches, then fast-forwards the main branch only: it never switches your branch, stashes or forces, and stops before overwriting your changes; a main branch that cannot move is an answer, not an error, and the reply says why. It also closes Jig’s own writes whose pull request merged, squashed included, or closed. Knowledge that origin already decided reads aslandedand no longer counts as waiting for you.jig status --jsonnow says when the clone last fetched and how far it is behind and ahead, and the status page asks for a refresh while it is behind. See Keeping the view current.- A task nobody started is paused directly. A pause request is no longer offered for a task
that was never started, since no stage would take it;
jig task pause <id>does it, and now takes--revisionand--json. A pause whose stash fails puts the request back in the queue. - Your agent offers the task the queue names. Wherever it suggests what to take next, it asks
jig queue nextfirst, and puts another task ahead only by saying why. - A GitHub pull request is reviewed on the diff GitHub shows.
jig pr fetchreads from the merge base GitHub’s “Files changed” starts at, so comments land on it even after the base branch took part of the pull request; when the two differ it also shows the author’s own change. Proven by tests, not yet on a live pull request. See Review a colleague’s pull request. - Filing a task’s goal no longer takes the task. Reading a task’s documents, or writing the goal
of a task nobody started, no longer marks it as another session’s, so
jig queue nextstill offers it to others.
0.44.0 — 2026-11-12
A review of a colleague’s pull request now reads like one: each finding carries its severity’s colour and a number, and the summary lists them by severity. The review skill is installed for you, so it works in a clone of any repository. Several knowledge documents can be decided in one write, and a refused pull request names the GitHub account that asked.- Review comments carry a severity and a number. A review draft names its four severities in
the review’s language (
=== levels) and gives each comment one (=== comment P2 R42 …), with a one-line title first.jig pr comments checkputs the colour (🔴 🟠 🟡 🟢) and the finding’s number at the start of each comment, and adds a legend and a list of findings by severity to the summary; a comment moved into the summary keeps its number. All of it is part of what you approve. A draft without levels is posted as before. Not yet posted on a live pull request. See Review a colleague’s pull request. - The review skill works in any folder. The installer and
jig self-updateplacejig-pr-reviewfor you: a link in~/.claude/skillswhen you have Claude Code and in~/.agents/skillswhen you have Codex — a link, or a marked copy where links cannot be made (Windows without Developer Mode). A skill of your own under that name is left alone;install.ps1 -Uninstallremoves Jig’s copy. There is no switch to turn it off yet: a link you delete comes back at the nextjig self-update. Coming from 0.43.0 or older, the firstjig self-updateruns the old updater, which does not place it: runjig self-updateonce more. In Claude Code your copy wins over a project’s, sojig statussays when the two differ.jig pr fetchandjig pr followupnow printmethod:andshow:, where the skill finds the review method. See Install. - Decide several knowledge documents in one write.
jig knowledge decide --accept <id> --reject <id> --reviewed <id> …decides them all at one revision, as one commit and one push onknowledge/decisions, never in your working tree; any refusal refuses the whole call before anything is written. See Deciding knowledge. - A refused pull request names the account that asked. When
gh pr createfails during a ship, the error now ends with the GitHub account Jig asked as and where it came from — including aGH_TOKENorGITHUB_TOKENin the environment, with the variable to remove. See Two GitHub accounts.
0.43.0 — 2026-11-11
Jig’sgit push and fetch over HTTPS now go as the project’s GitHub account, as its gh calls
already did, so a machine with two accounts no longer pushes as the wrong one. Under
verify.full_run: ci, a task cut from an epic is verified against the epic, not against main.
Two refusals that read as failures now say what they are waiting for.
- A push over HTTPS goes as this project’s GitHub account. Jig’s pushes, fetches and branch
deletions on an HTTPS
originuse the account itsghcalls already use, not your credential helper’s. When several of your accounts may push, the active one is not among them and none is named, a push over HTTPS now stops with nothing sent, atagent.git: pushtoo. A change under.github/workflowsneeds theworkflowscope on that account’sghtoken. SSH and aGH_TOKENin the environment are left as they were. A real push as a second account has not been checked yet. See Two GitHub accounts. jig verifymeasures a task from the branch it was cut from. Underverify.full_run: ci, a plainjig verifychecks what changed since the current task’s base, so a task of an epic no longer re-checks the whole epic. Without a task, with tasks on the branch that disagree, or with a base this clone cannot find, it measures fromgit.base_branchas before; the header names the task (Configure verification).jig upgradenames the pull request it waits for. When the upgrade to this version is already on an unmergedjig/upgrade-<version>branch, Jig asks GitHub or GitLab once: an open pull request is named with its URL and refused asnot-mergedinstead offailed, so a program shows the upgrade as waiting for its merge. A merged or closed one is named with its state. See Reading Jig as data.- A refused close says why GitHub or GitLab could not be asked. When
jig task set <id> status consolidatedcannot learn whether the pull request merged —ghorglabmissing, not signed in, an error, no answer in time — the refusal names the cause and says the pull request may already be merged: run the same command again once the forge answers. - A stub costs no extra processes.
jig statusandjig contextread a knowledge document that links a source file the way they read any other, without starting processes for it, unless a directory on the way to that source is a symbolic link. - Fixed: the status page and
jig status --jsonkept “A pull request was open at the last housekeeping run” for a task closed after that run; a task with a pull request closes only once it merged, so the item is gone.
0.42.0 — 2026-11-10
Jig can now review a colleague’s pull request on GitHub or GitLab and post the review only as you saw it. It works as the right GitHub account for each project, whichever onegh has active. An
idea being talked through is kept in a draft, so a cut-off session loses nothing. Commands start far
fewer processes, which Windows feels most.
- If you have several GitHub accounts, name this project’s once. Every
ghcall Jig makes about your project’s repository, andjig gh <args>for your own, runs as the clone’s account:github.accountin your.ai/config.local.yaml, otherwise the one accountghholds or the one that may push here.jig statusshows which it found. When several of yours may push and the active one is not among them,jig task shipandjig ghrefuse and say to runjig config set --local github.account <login>; the agent asks you once. With several accounts signed in it needsgh2.40 or later, and it never runsgh auth switch.git pushover HTTPS still goes asgh’s active account (Known issues). See Two GitHub accounts. - Review a colleague’s pull request. Give the
jig-pr-reviewskill the link of a GitHub pull request or a GitLab merge request: it reviews it in a worktree of its own without touching your checkout, shows the review word for word, and after your yes posts exactly that version (jig pr). After the author’s fixes, a follow-up answers each earlier thread “fixed” or “still open”. Posting to GitLab and the follow-up have not yet been checked on a live pull or merge request. See Skills and Review a colleague’s pull request. - An idea is talked through before it is written, and kept meanwhile.
jig-ideaworks in circles of a few rounds, asks all of a round’s questions at once, numbered, and writes the specification only after your yes. The conversation lives in a draft git never sees (.ai/workspace/ideas/<id>/draft.md,jig spec draft list|write|rename|drop), andjig statusshows adrafts:line while one exists (Keep an idea’s draft).jig spec shipputs the draft away. A spec gains a “Set aside” section, and closing it lists what is still there. - Commands start fewer processes. Counted on a project with 144 knowledge documents and 47
tasks:
jig status2024 → 589,jig task current196 → 46,jig queue next287 → 108, andjig upgrade --dry-runin link mode 473 → 89. These are process counts, not timings; a process start costs about ten times more on Windows than on macOS. What each command prints is unchanged. jig spec item filerefuses an already filed item withalready-filed.already-existsnow means only that the--newtask id is taken; a program that readalready-existsfor the item must read the new code. See Reading Jig as data.- An autopilot pull request is short. Its body no longer carries the design or the run’s journal: what and why, the review and verify results, and the report’s blocks, in English. Stop and end reasons stay in your language.
- Fixed: Homebrew bash 5.3 on macOS could crash now and then with exit 139 (SIGSEGV) when Jig
restored the locale in a subshell; Jig no longer sets the locale in its own shell.
jig task pauseandjig task autopilot stageno longer fail with “cannot take the pause request … out of the queue” whenjig queue cancelremoved the request but exited non-zero. Undergit.branch_template: {id}, without a prefix, merged task branches are deleted again: a branch is Jig’s when a task record names it.
0.41.0 — 2026-11-08
Code that has not been released no longer reaches your project by accident. Until now a Jig installed frommain showed the last release’s number, and jig upgrade copied its unreleased
code into a project under that number. jig context is about fifteen times faster, a knowledge link
whose file changed can be dropped, finished tasks leave the queue, and writes on Jig’s own branches
stop bringing back what you rejected.
- A project in copy mode takes released Jig only.
jig initandjig upgrade, dry runs included, refuse a Jig checkout that is not at the release tag of its version, or that has local changes there, asunreleased-source. The message says where the checkout stands and gives two ways out: return it to a release, or take that code on purpose with--unreleased. A project that took it recordsjig.version: 0.41.0+<sha>(+<sha>.dirtyfrom a checkout with local changes), and an upgrade from a released Jig records the plain number again. Off a tag,jig --versionandjig statuscall the versionX.Y.Z+<sha>, andjig statussays when the global Jig is on the development channel.jig self-updateon a branch andinstall.sh --ref <branch>say the same, andinstall.ps1 -Ref <branch>asks before it sets up a project from such a Jig (the answer defaults to no).jig verifyno longer asks for framework files from such a checkout, andjig doctorwarns instead of failing. Link mode is unchanged. How to develop Jig next to a released install is inCONTRIBUTING.md. If your Jig was installed frommain, or is a clone you pull, see When the source is not a release. jig contextreads knowledge without a process per document. On a repository with 139 documents it takes 0.6 s instead of 8–10 s, andjig task list --jsongets faster with it. A knowledge document saved with CRLF line endings is now read on macOS and Linux too.- A knowledge link whose file changed can be dropped.
jig knowledge reject <id>takes an accepted stub whose source ischanged,unrecordedormissing, and retires it. Injig knowledge proposed --jsonandsources --json, every entry carriesdecidableand areason(not-on-base,not-on-branch). A write that cannot be decided yet is refused with that code before it writes anything. See Reading Jig as data. jig knowledge read <id> --jsongives one document’s text, and for a stub the linked file as it is now.- Knowledge JSON keeps to what the files hold. A file name with a byte that is not UTF-8 no
longer reads as another file: each proposal and source record carries
lossy, and so do the--diffandreadanswers. One character from U+100000 up no longer turns every non-ASCII letter of an answer into?, and a proposed stub has the same state insources --jsonandsources --diff --json. - Finished tasks leave the queue. Closing, abandoning or archiving a task takes its queue entry
out, and so does every housekeeping run;
jig queue prune [--dry-run]does it on demand. A wait on a finished task is dropped as met, while a wait on abandoned or archived work still reads broken. A task taken back is not queued again:jig queue setputs it back. jig spec item file <spec> <item> --new <task>files the task and names it on the roadmap item in one write. Filing first and naming after was always refused asstale-revision.- Writes on Jig’s own branches judge the branch by what origin answers. A roadmap or knowledge
write, and
jig writes ship, no longer carry a rejected edit into a new pull request, refuse withbranch-has-other-commitsafter a squash merge, trust a branch deleted on origin until you prune, or push a dropped branch back after a prune and a failed push. An earlier edit that still waits where this one cannot follow is refused aswrite-still-waits, andjig writesstops counting an edit that is over. The lock a write holds is bounded: network calls under it have a deadline, a dead holder’s lock is taken back atomically, and the merged mark is written under the lock. On Windows, whatgit worktree removeleaves of Jig’s tree (links, empty folders) is cleared instead of refusing every later write astree-in-the-way. Moving the only item of a roadmap section within it no longer adds a blank line and a commit each time; a write never takes another spec’s branch name (spec/x-2whenx-2is a spec); a write without--revisionis no longer refused asstale-revisionfor a write that landed meanwhile; andjig writes shipno longer fails when you deleted the local branch: it takes the branch back from origin. - Context acknowledgements say what they stand for.
jig context guardnames why each pending document is required and at which stage the acknowledgements it accepted were made.jig context acknowledgerecords the stage and takes--revoketo withdraw a claim (with--stageit is refused). A refused acknowledgement now records nothing and leaves no temporary file behind. - A profile can take over a check of another.
covers: [<profile>:<check>]in a profile’sprofile.yamlstands that check of the lower profile down when both run, and the run and--explainsay who covers it.php,laravel,nodeandpythonname their test checktests(checks: [tests]), andlaravelcoversphp:tests: a Laravel project runs its suite once, inphp artisan test, with.ai/verify/php.mapread afterlaravel.map. A project profile over a stock one takes its tests the same way.jig upgradekeeps a stock profile you edited, so such a copy goes on as before until you addchecksorcoversto it yourself. See Verification profiles. - A person can take a stopped autopilot run over.
jig task autopilot <task-id> handover --by human --answer "<your words>"ends a stopped run, also one at the unattended repair limit, with your words in its record and its report, and a Telegram message says so. The task no longer shows as waiting injig statusand on the status page, its design approval is yours from then on, and it never starts a new run. See Taking a stopped run over. jigends when it is told to.kill,pkillor Ctrl-C now stop a jig command and every process under it, also when it waits on a long command; what does not end on SIGTERM gets SIGKILL afterJIG_TERM_GRACEseconds (default 5). This holds on Git Bash too.- A forge behind an SSH host alias is found. With
originatgit@github-personal:owner/repo.gitand the alias mapped in~/.ssh/config,forge: autoasksssh -Gfor the real host, sojig task shipandjig spec shipopen pull requests again. - An agent’s wait on a check has an end. The
jig-verifyskill forbids waiting on a run by watching its output for a line, as it already forbadepgrep -f, and any wait loop an agent writes has a time limit: one agent looped for 36 hours after its run had passed (#426). - Fixed: the session hook printed an
unbound variableerror and ran housekeeping daily whateverhousekeeping.cadencesaid. A task closed from an agent session with--revisionwas always refused asstale-revision. Housekeeping no longer flags an archived task whose fate was already decided (abandoned or absorbed) as needing consolidation. A spec whose id contains.tmp.is no longer hidden fromjig writes.jig upgrade --landno longer calls an upgrade that returns a project to a release landed whileoriginstill records the unreleased build.
0.40.0 — 2026-11-05
A program can now close a task, read and change your settings, read the knowledge waiting for a person, decide it, and change a roadmap, all without moving your checkout. The agent works from the queue: it sets priorities from one scale and is not advised a task another session works on. A review reads behaviour and standards apart, andjig task ship no
longer merges part of a change.
- A roadmap can be changed, and knowledge decided, without touching your checkout.
jig spec item add|move|fileandjig knowledge accept|reject|reviewed --revision <n> --jsoncommit on a branch of their own (spec/<id>,knowledge/decisions) in a tree Jig makes and removes, and go as far asagent.gitallows; edits in a row share one pull request. The answer names the branch, commit and pull request and whether it merged, refusals come as codes, and atagent.git: nonethey are refused. A write publishes only its own commits: what Jig did not write and origin does not hold is refused (branch-has-other-commits), and so, atagent.git: pushor above, is a base origin does not have (base-not-on-origin). Each roadmap item injig spec list --jsonhas anid, and what waits shows aswaitingthere and injig knowledge proposed --jsonandsources --json, injig writesand on awrites:line ofjig status.jig writes shipcarries a waiting edit further, and merges it atagent.git: merge.jig knowledge reviewedtakes several ids. The text forms ofaccept,rejectandreviewedstill change your working tree. With--separate-git-dir, in a submodule or in the worktrees of a bare repository, the clone’s revision moves to<git-dir>/jig/revision, so a revision held from before reads as stale once. See Writes on a branch of their own; four faults are in Known issues. jig task shiprefuses a merge that would leave part of the change behind. When it would merge (agent.git: merge, orautopilot.git: mergein a run), not on a draft, when what is staged leaves changes to tracked files or new files in the tree, it names them and refuses before the commit: nothing is committed, pushed or asked of the forge.--partialsays the rest is not this task’s, and what it leaves is still named. Belowmergea person takes the next step, so the warning stands as it was;jig spec shipand the upgrade are unchanged. See Choose what the agent can do.- A code review reads behaviour and standards apart. T2’s review and T4’s independent review are
done by two fresh readers in turn. One asks whether the change does what was asked and whether a
guarantee can be walked around through another path. The other checks every written rule one by
one,
AGENTS.md,CLAUDE.md,CONTRIBUTING.mdand linter settings included, plus a short list of code smells that is at most a P2 and never stops the task. Lean depth keeps both; a repeat review of a small fix uses one. See Risk classes and routes. jig queue nextpasses over a task another session works on. A session that works a task leaves a note for the whole clone, even before the task has a branch; the advice names such a task instead of offering it,jig queue listprints the same line, andjig queue next --jsonlists it undertaken, withtakenas a newreason. A note lapses aftercheckout.busy_ttl, and working on the task takes it over. This needs a runtime that names its sessions, as Claude Code does. See Order the work.- The agent gives a task its priority. The
jig-taskskill now holds the0–5scale and answers “set priorities”, the Jig section ofAGENTS.mdsays the answer goes in the queue, andjig-idea,jig-releaseand a phase’s run file tasks with a number.jig task newreminds on stderr (not queued: <id> — …); its stdout and--jsonare unchanged. See Order the work. - Two faults of
jig upgrade --landandjig statusare gone. An upgrade pull request left open for an older version no longer holds backupgrade-availableinjig status --json.--landin a linked worktree on the upgrade’s branch is refused asupgrade-blockedand names the main checkout, instead of checking the base branch out there. The third entry 0.39.0 listed, that a failingglabreads as nothing to land, was wrong: a failingglabwas already reported as a failure, and a test now holds that. - A task can be closed from a program, checked against what it read.
jig task set <task-id> status consolidatedtakes--revision <n>and--jsonasjig task resumedoes: a write another change has overtaken is refused withstale-revision, and the answer is the closed task, or a refusal with its code —not-closablewhen the close is not offered (the knowledge decision is not recorded, or the pull request is not merged),not-foundfor an unknown task. The two flags are refused on any other key. From an agent session, such a close was refused asstale-revisionevery time until 0.41.0 fixed it. See Closing a task. - Knowledge waiting for a person, as JSON.
jig knowledge proposed --jsonlists each proposed document with its type, domains, path,paths, summary and, for a stub, the file it links;jig knowledge sources --jsongives each linked source’s state (changed,unrecorded,missing,ok, or the stub’s own status until it is accepted) andjig knowledge sources --diff <id> --jsonthe difference between the approved text and the file now, always as valid JSON whatever bytes the file holds. A document that does not exist is refused asnot-found. The text forms are unchanged. See Reading Jig as data; three faults in these answers are in Known issues. - A triage task closes as done.
jig task set <task-id>-findings status consolidatedcloses the taskjig task shipfiled for open review findings in one command, once you have decided each of them — no class, no review and no separate knowledge decision asked for. It is listed as finished; until now the only way out wasjig task abandon, which recorded a decided triage as given up. A triage task you classified or started follows its route like any other. See Review findings. - Autopilot over several tasks asks the queue before each start. When you hand over a list of
tasks, the agent runs
jig queue nextbefore starting the next one; a more urgent task outside your list is named to you instead of being passed over (without stops, the running tasks finish and nothing new starts), and a task another session works on is never started. See Several tasks in one run. A phase run asks the same way: a more urgent task outside the phase holds the next start, and the run stops withjig spec stopto ask you. - Your settings as JSON.
jig config keys --jsonlists every setting Jig reads with its value, where the value comes from (your local file, the project’s or the default), who may answer it, what kind of value it takes and the choices, and a one-line description;jig config setandjig config unsetanswer with--jsontoo, and take--revision <n>. A secret such as the Telegram token is never printed, only whether it is set. See Your settings.
0.39.0 — 2026-10-29
An upgrade that ends in a pull request is followed to the end, and a project upgrades on every machine, whoever installed it. Until nowjig status forgot an upgrade’s pull request as soon as
it was opened and offered the upgrade again, and a committed .ai/manifest that named the folder
Jig was installed in on one person’s machine stopped jig upgrade on everybody else’s.
A project on Jig 0.38.1 or older: run its first upgrade to 0.39.0 with the Jig on your machine,
by its full path. The fix below lives in the new Jig, but Windows, in Git Bash:Then
jig upgrade in a project is run by
the project’s own copy — the old one. Where .ai/manifest has a jig.source: line naming a
folder that is not on your machine (such as /Users/<someone>/.local/share/jig),
.ai/scripts/jig upgrade stops with
upgrade: cannot determine the framework source root; pass --from <dir>. So does asking your
agent to “upgrade Jig”, and a jig shell function or alias that runs the project’s copy first.
Do it once, in the project’s root folder, with the paths the installer uses:macOS and Linux:.ai/scripts/jig version prints jig 0.39.0 and .ai/manifest says
jig.source: global when that Jig is the one on your PATH (else it names its folder). Finish the upgrade as usual
(Upgrading); from then on a plain jig upgrade works.- A project upgrades from the Jig on your machine, wherever it was installed from.
jig upgradenow looks for the Jig to copy from in order: the checkout the runningjigbelongs to, the source.ai/manifestrecords when that folder is a Jig checkout here, then thejigyourPATHfinds. That last one is never used when it is older than the project’s Jig — that would be a downgrade — and the refusal then asks forjig self-update. When nothing is found, the message says where it looked, never the recorded path. The manifest now records the Jig on your machine asjig.source: globalwhen it is the one yourPATHfinds, which each machine reads as its own Jig, instead of the folder it lives in; an old manifest needs no editing — the first upgrade that places a file writesglobal. See What the upgrade does. jig statusfollows an upgrade’s pull request. When an upgrade ended in a pull request, the plainjig statusshows anupgrade pull request:line while it is open, and again once it is merged but your base branch here still has the old Jig. It reads what the lastjig housekeepingheard from your forge, so it is as fresh as that run.jig upgrade --landbrings a merged upgrade in. Once the upgrade’s pull request is merged, it asks the forge, puts you on the base branch, fast-forwards it to origin’s and deletes the upgrade’s branch — on origin too when your agent may push. While the pull request is open, with uncommitted changes, on a branch other than the base or the upgrade’s, or with a base branch that cannot be fast-forwarded to origin’s, it refuses and changes nothing. See An upgrade is a change of its own.jig task shipships the change instead of refusing it. With nothing staged it now stages the changes to files Git already tracks and lists them; it used to refuse. It never stages a new file for you: with nothing staged, a new file that is neither staged nor in.gitignoreis a refusal that names it, and nothing is sent. When something is staged, that is the commit, and it warns about every change it left out.jig spec shipand the upgrade still commit only what is staged. See Choose what the agent can do.jig spec listis fast again. 0.38.0, which began counting merged tasks in a spec’s progress, read every task’s state and the whole housekeeping log once per spec, so the listing slowed down with every spec and with the size of.ai/runtime/housekeeping.log. It now reads them once per listing, and only the newest run of the log. Measured on a real project with 20 specs and an 8.8 MB housekeeping log:jig spec list --jsontook 6.8 s on 0.38.1 against 0.76 s on 0.37.0. A separate measurement of CPU time on a real project, on a machine at a load average of 130–200, gave about 1.2 s now, against 8.4 s on 0.38.1 and 1.0 s on 0.37.0.jig statusandjig task list --jsonnow read only the newest housekeeping run too; that was not measured.- The housekeeping log stops growing. Every
jig housekeepingrun that is not a dry run now trims.ai/runtime/housekeeping.logto the last ten runs, each with every record and at most 200 other lines of output, and of older runs keeps only the purge linesjig measurereads, so its history is unchanged. On a copy of a real project’s log that took 8.8 MB down to 91 KB. The log is rewritten in place, and a trim that fails leaves it as it was. See What a removed worktree takes with it. - A program sees the upgrade’s pull request.
jig status --jsonhas two new kinds,upgrade-pull-request-waitingandupgrade-pull-request-merged, withpull_request({branch, base, state, fetched_at}) andversions({to}), and holds backupgrade-availablewhile one stands;jig upgrade --land --jsonreportslandedornothing-to-do, and refuses asnot-mergedorupgrade-blocked..ai/runtime/forge-cachelines carry two more columns, the pull request’s head commit and its address; a line written before reads as it did. See Reading Jig as data. - A re-review stays narrow when only a global knowledge document moved.
jig task receipt <id> --since-reviewused to answerfullwhenever the knowledge the review read changed, and every task’s consolidation editsGLOSSARY.md,ARCHITECTURE.mdorRULES.md, so merging the base branch in forced a full re-review almost every time. The receipt now lists each knowledge document it read; when only global documents changed, the answer isnarrowand the diff of each follows the change since the review. A document matched through the task’s own files or domains, or one that newly applies or no longer does, still meansfull. See Inspect the change and its review. - A task’s documents can be read as data.
jig task artifacts <id> --jsonlists all twelve kinds of task document with their state (present,empty,missingorunavailable), size and time of the last change, andjig task artifact read <id> <kind> [--json]prints one of them. Both find the workspace of a task in a worktree too, which only Jig knows how to reach. See Reading Jig as data.
0.38.1 — 2026-10-29
jig task listandjig status --jsonread each task once. Each field of a task’s state used to cost a process of its own, so the listing slowed down with every task you filed; the output is the same as before, byte for byte. Measured as the median of five runs on macOS (bash 3.2, arm64), on a machine heavily loaded by other work, so the absolute times are pessimistic: in Jig’s own repository (14 tasks)jig task list --all --jsonwent from 4.66 s to 0.71 s andjig status --jsonfrom 0.65 s to 0.55 s; in a generated, synthetic project of 40 tasks,jig task list --all --jsonwent from 10.23 s to 0.98 s andjig status --jsonfrom 1.21 s to 0.78 s.jig task setnamestriage_taskandtriage_ofas Jig’s own. It refused them before as an unknown key; it now sayskey is not writable, as it does for the other keys only Jig writes.
0.38.0 — 2026-10-29
What one agent knew now reaches the next one: the goal of a task, a neighbouring repository’s design, the small review findings nobody fixed, and why a task was given up. Until now each of them could sit where the next agent does not read — a template-onlytask.md, another repository, a
merged pull request’s body, a gitignored note — and the status page showed a spec standing still
while its tasks merged.
jig task startasks for the goal. A task whose## Goalis empty, or holds only the template’s comment, starts with a warning; a T3 or T4 task is refused until the goal is written.jig task list --jsonlistsstartas unavailable for it, with the same reason. See File a task, then start it.- A task can link a task or spec in a neighbouring repository. A
Linked: <repo>#<task-id>orLinked: <repo>#spec/<spec-id>line intask.md—<repo>a path from your main checkout — makesjig context resolvelist that task’s notes, or the spec’sspec.mdandroadmap.md, onlinked:lines. The agent records reading them like knowledge, so an edit there shows aschanged since acknowledged; what is not on this machine shows asunreachable:. Jig only reads the other repository. See A task that continues work in a neighbouring repository. - A spec’s progress counts merged work, not only checkboxes.
jig spec list,jig spec list --jsonand the status page count a roadmap item done when its task is closed in this clone or the lastjig housekeepingsaw it merged, even before its checkmark reaches the branch you read — in a phase run the checkmarks reach the epic’s remote only with the next pull request. Each item injig spec list --jsonhas a newdonefield (Reading Jig as data). - Open small findings go to one triage task. When
jig task shipopens a pull request (not a draft) and P2 or P3 findings are still open, it files one task,<task-id>-findings, with each of them word for word and a link to the pull request — not started and not queued, so it waits for you. A second ship files no second one.jig task findingssays where they went, and the autopilot’sendmessage in Telegram names the count and the task. See Review findings. - Giving a task up records why, and its roadmap item follows.
jig task abandon <id> --reason "<why>"stores the reason;--moved-to <repo>#<task-id>(or<repo>#spec/<spec-id>) says where the work went and, when that task is not there yet, prints the command that files it — for a spec, it says to add the item yourself. For a task from a spec, the newjig spec drop <id>checks its roadmap item and appends— moved to … (<date>): <why>or— dropped (<date>): <why>— in a checkout of the epic, or onspec/<spec-id>for a spec without one, whichjig task abandonon your main branch switches your checkout to and leaves it on; the roadmap on your main branch is never edited. A task linked to a spec is now refused byjig task abandonwithout--reason, and byjig task set <id> status abandoned. See Giving a task up, or moving it elsewhere. - A resume whose stash conflicted can be retried. After
jig task resumeleft the stash’s conflicts in your files, resolving them and running it again ends the pause instead of applying the stash a second time. See Pause and resume. - A stopped worktree setup stops on Windows too. Under Git Bash, a
worktree.setupstopped atworktree.setup_timeout, or still running when Jig is interrupted, now has the Windows process tree it started —phpundercomposer,docker— ended before its group is signalled.
0.37.0 — 2026-10-27
Work nobody finished is put away instead of deleted, and a task that another one solved can be merged into it. Until now housekeeping deleted an abandoned task’s notes afterabandoned_ttl and the trash
period, and a task that a newer one had made redundant either sat in your lists for ever or was
abandoned with its documents lost.
- Housekeeping archives unfinished tasks instead of deleting them. An abandoned task past
housekeeping.abandoned_ttlno longer goes to the trash and then away: it gets the new statusarchived, and its notes stay in.ai/workspace/tasks/<id>/with no time limit. An active or ready task nobody touched forhousekeeping.stale_after(60 days unless you changed it) is now archived too, where it used to be only flaggedSTALE_CANDIDATE— unless it has a pull request, a flag of its own or a worktree, or its branch is checked out with changes; those are still only flagged. Only the workspace of a task that was closed after a merge still passes through the trash. An archived task leaves your lists;jig task listandjig statussay how many there are (archived: N), the status page has an “Archive” block, andjig task list --status archivedshows them. See Archive and unarchive and Housekeeping. jig task archive <id>andjig task unarchive <id>. Put an active, ready or abandoned task away by hand, and bring it back to the status it had.jig task setcannot write or leavearchived. A task archived while its work was merged anyway is reported by housekeeping and the status page withjig task unarchive <id>first, since closing it starts there.jig task merge <from> --into <to>merges a task into another. The documents of<from>are copied to<to>’s notes underabsorbed/<from>/,<to>’stask.mdgets an## Absorbed: <from>section,<from>is archived with the reasonabsorbed, and queue waits on and of<from>move to<to>; a move that would close a circle refuses the whole merge before anything changes. With--partialthe task stays open, both sides note the overlap and the queue is untouched. When the receiving task ships, its commit and pull request carry anAbsorbs: <issue>line, so your tracker’s own integration can link them; Jig never calls a tracker. A merge can always be run again, andunarchivebrings the task back but not the queue waits that moved. See Merge a task into another.- A task that cannot be archived no longer ends the housekeeping run. The task is kept, named on
the error stream as
housekeeping: <id> was not archived: …, the run goes on with the rest, and it exits 3 withaction needed: a task could not be archived. - A program sees the archive and the links.
jig task list --jsonhasarchived_at,archived_reason(abandoned,stale,manualorabsorbed),archived_from,absorbed_into,absorbs,absorbs_partlyandpartly_inon every task, a count of archived tasks indata.archived, and the actionsarchiveandunarchive. Schema 1 stands: archived tasks appear only when asked for with--status archivedor--all(Reading Jig as data). - For people who release Jig itself. CI opens one issue, labelled
red-main, whenmaingoes red and closes it when a full run is green again. A pull request that raises the version runs the Windows shards and is refused while the latest completed run onmainis not green. A push tomainwhose pull request already tested the same tree on every platform skips the suite and goes straight on to tagging. Nothing here changes what an installed Jig does.
0.36.0 — 2026-10-27
A task worktree can be finished by your project’s own command, and a folder of packages can be shared with just the task that edits them. Until now a worktree got a copy of this checkout’svendor/ — after composer dev:link, links into packages/ — so a task ran either on dangling
links or on whatever your package checkouts held, never on your lock file.
worktree.setupruns your command in a new worktree. After the share and the carry,jig task start --worktreeand everyjig task bootstraprun it in the worktree, on this machine. It is told the task, the checkout the worktree came from, the folders shared with it (JIG_SHARED) and the carried links that lead nowhere (JIG_DANGLING), so one command can put a task on the lock’s versions or on your local packages. It is stopped afterworktree.setup_timeout(10 minutes), is never fatal, and a failure stays on the task —setup=failed (exit 1)injig status, asetup:line injig task route— until a bootstrap succeeds. See Finishing a worktree with your own command.--share <dir>shares a folder with one task.jig task start <id> --worktree --share packages, orjig task bootstrap <id> --share packagesfor a task already running, gives that task the linksworktree.sharegives every task. See Sharing for one task.- The hint about an unshared folder of repositories changed. Starting a worktree names
--sharefor a task that edits it, as an information line rather than a warning.jig statusnames both ways to share it, and stays quiet once the project has aworktree.setup. - Housekeeping deletes merged branches on the remote in one push. It used to push once per
branch, plus an
ls-remotewhen a push failed. Over HTTPS each of those calls can open your credential helper’s dialog — on macOS a Keychain prompt after a Homebrew upgrade of git — so a dozen merged branches meant dozens of prompts every day. A run now makes at most two calls to the remote, however many branches it deletes, and a branch that moved after its merge is still kept (#317).
0.35.0 — 2026-10-26
A paused task can be resumed by a program. Jig UI can now take a task off pause from the clone’s main checkout, against the revision it read, and read the answer as data.jig task resumetakes--revisionand--json. The resume is checked against the clone revision the way queue writes are: anything written in the clone since your read refuses it withstale-revision, and nothing changes. With--jsonit answers with the task asjig task list --jsonlists it and what the resume found — days paused, the stash, uncommitted files and overlap with the base. A refusal says why in a code:not-found,not-paused,wrong-checkoutorstash-conflict. See Resuming a paused task.- Resume runs from any checkout when nothing was stashed. It used to refuse unless the task’s
branch was checked out where you ran it. Now that check applies only when the pause put work
aside with
--stash, because the stash is applied where you run it. A pause your agent made for a request stashes nothing, so a task in its own worktree is resumed from the main checkout. - The resume report describes the task’s checkout.
uncommitted:andoverlap:are read where the task’s branch is checked out — here or its worktree — or from the branch’s commits, not from whatever checkout you ran the command in.
0.34.0 — 2026-10-26
Many projects, kept up to date. Jig now tells a program which projects run an older Jig than your machine, a program can run the upgrade and read what it did, and your agent upgrades a project when you ask. A release made as a plain task now waits for you, unless an unattended run may merge it.jig status --jsonnames a project that needs an upgrade. A new item,upgrade-available, appears on the status page and in--jsonwhen the project’s Jig is an older release than the one on your machine; it carries both versions andjig upgradeas the thing to do. Jig UI lists the projects to upgrade from it. See What needs you.jig upgrade --json. The upgrade runs as before, its text goes to stderr, and stdout holds the result: from and to, the outcome (upgraded,staged,nothing-to-do,incomplete, andplannedfor a dry run), the branch, commit and pull request, the steps the release asks for by hand, and for a dry run what would stop a real one. An upgrade that cannot start answers with the codeupgrade-blockedand every reason. See Upgrading a project.- “Upgrade Jig” to your agent. The new
jig-upgradeskill updates the tool when a newer release is out (it asksjig doctor, never reads silence as “up to date”), dry-runs the upgrade, runs it, and does the steps the release asks for by hand where it can. Anything that would stop the upgrade — your uncommitted changes, a task’s branch checked out — it names and asks about, never works around. - A release made as a task follows
release.merge.jig task shipmerged a change that raised the version even withrelease.merge: human, as 0.33.0 was. A change into the default branch that raises the version inscripts/lib/version.sh,VERSION,package.json,composer.json,pyproject.toml([project]or[tool.poetry]) orCargo.toml([package]) is now a release: it is merged only in an unattended run withrelease.merge: agent, and a major one never — it is opened as a draft. Seerelease.merge.
0.33.0 — 2026-10-24
A repair release. On Ubuntu 25.10 and later Jig’s locks and counters did not exclude anyone, and a folder of packages shared with task worktrees could not be seen from a container. Both are fixed, and Jig now tells you when a folder should be shared.- Locks and counters hold on every system. Ubuntu 25.10 and later ship a
mkdirthat reports success to both of two processes making the same directory, and Jig claimed its locks withmkdir. Twojig verifyruns could run at once, two housekeeping runs could overlap, and the counter Jig UI and--jsonreaders watch for changes could lose a step. Every claim is now made by creating a file only if nothing is there, which bash itself does, whatever tools the system ships. Nothing to do on your side. - Shared packages are found inside a container. The links
worktree.shareputs into a task worktree pointed to the full path on your machine, so a container that mounts the folder holding both your checkout and its worktrees under another path (devilbox’s/shared/httpd, say) saw them broken and its tests could not find the packages. On macOS and Linux they now point by a relative path. A worktree made before this release keeps its old links; a worktree made anew gets the new ones. See Sharing a folder of packages you edit. - Jig names a folder you should share. A folder Git ignores that holds separate repositories —
Composer path repositories under
packages/, say — and thatworktree.sharedoes not name is pointed out byjig status, the status page andjig task start --worktree, with the line to add to.ai/config.yaml. - You can approve a design yourself with questions turned off. With
autopilot.unattended: true, a T3 or T4 task you were working on by hand had no command that recorded your approval.jig task gate <id> approvednow records it whenever the task has no autopilot run of its own; inside an unattended run the approval is still the agent’s. - Helpers on autopilot, sessions for you. The
jig-autopilotskill now starts every helper — reviewer, delegated stage, a phase run’s task agent — as a subagent of your runtime, never as a separate app session, which the Claude Code desktop app may refuse to start between your messages. When you ask for work to run alongside yours, thejig-taskskill opens its session in the same turn you asked. See Several agents at once.
0.32.0 — 2026-10-23
Jig now tells you which task to take next. The queue from 0.31.0 held priority, order and dependencies, but you or your agent still picked by hand, and a task waiting for another could be started first. One command now answers from the queue, andjig status, your agent and Jig UI all
read that one answer.
- Priorities have one meaning.
0broken or dangerous (data loss, a destructive operation, an install that fails),1a bug a user meets,2not a bug but it stops a user doing their own work,3friction,4an improvement or a new capability,5some day — so “bugs first” is set the same way by everyone. See Order the work. jig queue nextnames the task to take: never one that waits for a dependency whose change has not landed yet, then the most urgent priority (nonelast), a task already started before one not started, then position — tasks in different epics by the epics’ places. With nothing to take it says why: everything waits, everything is paused, or the queue holds nothing. A dependency on an abandoned or deleted task is called broken, with thejig queue undependto run; one Jig cannot judge yet asks you to runjig housekeeping. Active tasks that are not in the queue are counted, not advised. It reads only: nothing is written and nothing asks the network.jig queue next --jsongives the same answer in the shared envelope — the advised task, the reason when there is none, every dependency holding a task back with its state, and the count of tasks outside the queue. See Which task is next.jig statusshows the advice as anext:line after the task lines, and the status page as “Next task”. Without a queue file both look as they did.- Your agent asks instead of choosing. When you ask the
jig-taskskill “what next” or “take the next one”, it runsjig queue next, names the task and starts it; onnext: noneit tells you why and does not pick one itself.
0.31.0 — 2026-10-21
Jig can now be planned with. A queue keeps the priority, order and dependencies of your tasks and epics, and you can ask a running task to pause without losing the agent’s step. The queue lives in Jig, not in a tool beside it, so agents and programs read the same order. It is what the next phase of Jig UI is built on, and it is useful without it.jig queue— one queue per project, kept in.ai/runtime/of the main checkout, shared by its worktrees and never under git.jig queue set <id> --priority 0..5|none,jig queue move <id> --before|--after <id>or--top|--bottom,jig queue depend <id> --on <id> --reason <text>(a dependency always says why),undependandremove. An epic (epic:<spec-id>) is ordered beside tasks, and the tasks built on it within it. A move moves one item and never renumbers the rest. See Order the work.- A stale write is refused. Every
jig queuewrite accepts--revision <n>, the clone revision the caller read; a write without it is checked against the revision it reads itself. When anything in the project changed since, the write is refused with the codestale-revisionand nothing is written; two writers that send the same revision land at most once. jig queue list --json(orjig queue --json) — the whole queue in the shared envelope, in order, each item with its level, position, priority and dependencies. A write with--jsonanswers with the item as the queue now holds it; one that names a task or epic Jig does not have is refused with the new codenot-found. See The queue.- Ask a running task to pause.
jig queue request <id> pause [--reason <text>]leaves a request that holds until it is honoured orjig queue cancel <id> pausetakes it back, whatever stage the task reaches meanwhile. An autopilot run honours it at its next stage: the task becomes paused and the agent ends its session.jig task pausehonours it too. Continue withjig task resume <id>and a new session.jig task list --jsonshows a pending request aspause_request, and the task’sactionsgainrequest-pauseandcancel-pause-request, twelve in all. jig task autopilot <id> stageon a paused task now refuses with exit code 4 instead of entering the stage, and a pending pause request makes it pause the task the same way. Thejig-autopilotskill tells the agent to end its session there; a pause is not a stop.- A pause request reaches an agent working without autopilot.
jig context resolve --task <id> --stage <stage>, the first step of every stage skill, honours a pending request before it prints the context: the task is paused, the stage is not entered, the command exits with code 4 and tells the agent to end its session. Underneath it runs the newjig task pause <id> --if-requested --stage <stage>, which pauses only when a request is pending. - The queue in
jig statusandjig context.jig statusaddsqueue=<rank>/<count>andpriority=<p>to a queued task’s line, with what it waits for and a pending pause request on indented lines under it;jig contextwith a task addsqueue:lines. Without a queue file both print what they did before. - File a task from a program.
jig task new <id> --goal "<one line>"writes the goal under## Goalintask.md, with no file to write first. With--jsonit answers with the filed task, the objectjig task list --jsonlists for it; an id already taken is refused with the new codealready-exists, an invalid id or goal withusage. See Filing a task. - Fixed: a task filed without a goal no longer shows the template’s hint as its goal. The
<!-- … -->comment under## Goalis left out, sogoalisnullinjig task list --jsonandjig task new --json, andjig task list --goalssays(none). - Fixed: editing existing knowledge at the end of a task no longer asks for a new review. When
consolidation edited a knowledge document the review had read, marking the task ready, recording
the knowledge decision and
jig task shiprefused with a stale review. A document the task edited now counts as it is on the merge base; a change to it that arrives through the base still asks for a new review. jig spec shipships a spec you closed or removed. A spec removed byjig spec closeorjig spec removeused to be refused byspec ship, which read every removal as an epic’s final pull request; the removal had to be committed by hand. It now cutsclose/<id>from the default branch, stages only.ai/specs/<id>/, and opens the pull request as far asagent.gitallows; it never merges. See Agent ships.
0.30.0 — 2026-10-19
A repeat review after a small fix no longer reads the whole change again. Nothing that gates a task changed: an edit after the review still asks for a review before the task is finished.- A repeat review reads what changed since the review. When a review’s findings were fixed, or anything else was edited after it, the next reviewer — still a fresh helper — reads only what changed since the reviewed state and the findings marked fixed, not the whole change. On the task that brought this, the last repeat review, after a fix for CI, read one file with three lines added and one removed. It reads everything again when the design or the project knowledge the review relied on changed since. Applies to the code review and to the architecture review of risky tasks; an external reviewer of another runtime gets the same narrowed diff in its prompt.
jig task receipt <id> --since-reviewprints that difference and says whether the repeat review may be narrow (narrow), must read everything (full, with the reason, exit 1) or has nothing to do (none).--format pathslists only the files.- Nits are listed, not fixed. A P3 finding is never fixed after the review, at any route depth: it stays open and goes into the pull request. Fixing it would only have asked for another round. A P2 is still fixed unless your route is lean. A fix you ask for yourself after the review is an ordinary edit with a narrow repeat review.
0.29.0 — 2026-10-16
Jig can now be read by a program. The commands that report state print JSON with--json, in one
envelope that every command shares, without touching the network. The text form of every command
is unchanged. This is what Jig UI reads, and it is just as useful to
CI, a bot or an agent. See Reading Jig as data.
jig task list --json— every task of the clone: class, status, gate, autopilot run, branch, worktree, pull request and housekeeping flags.jig spec list --json— every spec with its phases, items, progress, epic branch and release level.jig status --json— what needs you, as items with a stablekind, from the same logic that draws the status page.- What a person may do next. Each task in
task list --jsoncarriesactions: start, pause, resume, approve the gate, answer a stop, set the class, ship, close, abandon, reopen — each offered only when the command would accept it, and when withheld, with the command’s own refusal as the reason. - One envelope.
{"schema", "revision", "generated_at", "data"}, orerrorwith a stablecode(usage,not-a-repository,not-initialised,failed) instead ofdata.schemarises only on an incompatible change. - A revision of the clone. Every write Jig makes raises one counter per clone, shared by its worktrees, and every JSON read reports it, so a program can tell that something changed. A file edited by hand or by git does not raise it.
- Pull request and CI state, offline.
jig housekeepingkeeps what it already asks the forge — pull request state and CI result — with the time it asked, andtask list --jsonreports it without calling the forge. - Checks on a pull request come back sooner. CI runs the suite in shares on every platform — Linux 2, macOS 3, Windows 10 — and every platform still runs the full set: about 14 minutes for a pull request without Windows instead of 24–38, about 23 with it instead of 34–37.
- Fixed: housekeeping obeyed your own git setting for untracked files. With
status.showUntrackedFiles=allin your git config, a run over a worktree holdingvendor/ornode_modules/listed every file in them and started a process for each: it took tens of minutes, could exhaust the machine’s open files, and each new session started it again. Withno, it left ignored paths out altogether, so a worktree holding the only copy of a nested repository’s commits could be removed. Housekeeping now asks git in a fixed mode, whatever your config says. - Fixed: the test suite could delete files where it was started. Out of file descriptors on a
heavily loaded machine,
tests/run.shcould run a test in the directory it was launched from and clean up there, removing that checkout’s.gitand.ai. It now checks every directory it makes and reports such a test as not completed. This concerns people who develop Jig itself.
0.28.0 — 2026-10-15
Every review is now done by an agent that did not write the change, whether you work beside your agent or hand a task to autopilot. No command, setting or file layout changed.- Every review is a second reader. T2’s review, T3’s architecture review and T4’s independent review go to a helper agent (a subagent, or the other runtime’s CLI when you chose one) that never saw the code being written. It gets the task and the design, not the author’s account of what was done, and every repeat review is a new helper. Until now, unless you had set a review model or runtime, a review done with you present ran in the session that wrote the code; T4 asked for a fresh context and autopilot for a helper. This is an instruction to your agent in the skills — no script can check which context a review ran in. A review costs one more helper per round. See Concepts.
- T4’s review goes further. It runs on another model or runtime than the code when your
settings choose one (
claude.review_model,codex.review_modelorexecutor.review_runtimeunlike the implementer’s); otherwise the pull request says the review ran on the same model, and the ship is not held up. Every acceptance criterion needs evidence, and every serious finding marked fixed is checked by undoing the fix and watching its test fail. See Autopilot: helpers on another model. - A link to Jig UI’s documentation in the site’s top bar and on What’s next.
0.27.0 — 2026-10-14
A stage can go to a helper in Codex as well as in Claude Code, to the other runtime’s CLI, and to a different executor for each task of a roadmap wave. Every new setting is unset by default, so a project that sets none of them works as before.- Codex helpers for coding and review. New local keys
codex.implement_modelandcodex.review_model, the Codex counterparts ofclaude.*_model. When a helper you chose cannot start, your agent is instructed to stop the stage with the reason rather than do it silently itself. See Helpers on another model. - A stage in the other runtime. New local keys
executor.implement_runtimeandexecutor.review_runtime(claudeorcodex), withexecutor.implement_modelandexecutor.review_modelfor that process. Your agent starts the other CLI in the task worktree with limited tools, the review in a fresh process, then checks the diff, findings and receipt itself; on a missing CLI, a refusal or an interrupted run it is instructed to stop the stage. These are the agent’s instructions; the scripts store and show the choice. Both directions were run on macOS; on Windows only the Git Bash CI ran, not a signed-in CLI.jig-setupasks about them when the other CLI is installed. See A stage in the other runtime. - Different executors in one roadmap wave.
jig task set <id> executor_implement_runtime codex(and the other threeexecutor_*keys) beforejig task startoverrides your local choice for that task only (inheritremoves the override);jig task routenames where each value came from, and the choice is fixed when the task starts. Two agents of different runtimes working at once in one wave was not run. See Different executors in one roadmap wave. - Your answer resumes a stopped unattended run. Answering a run that stopped for a decision
records your words (
jig task autopilot <id> resume --answer <text> --by human) and carries on, without giving it more attempts at a failing change: a run that used up its repairs still ends in a draft. An approval the agent gives afterwards is still labelled as the agent’s. - The upgrade puts you back where you started. At
agent.git: pushorpr, ormergewhen the run printednot merged:,jig upgradeused to leave the checkout onjig/upgrade-<version>, and housekeeping never deletes a branch that is checked out, so it outlived its merged pull request. Now the run ends on the branch you started from; inside a worktree of its own it does not move. See Upgrading. jig-setupasks about every personal setting. It now asks aboutrelease.merge,git.delete_merged_branchesand theexecutor.*keys, and names all four helper keys.
0.26.0 — 2026-10-10
More waits reach your Telegram, a task can carry its tracker issue, and a pull request names the linked rules a task edited. The two new keys are off until you set them; phase-run stops and the linked-sources block need no setting.- A phase run’s stop reaches Telegram. New
jig spec stop <spec> --phase <n> --reason <text>, which a phase run’s coordinator runs when a wave waits for you; it uses your existing Telegram setup. See Messages in Telegram. - An ordinary session waiting for you can message you. New local key
notify.interactiveand.ai/scripts/jig-notify-hookfor Claude Code’sNotificationhook; with the key on,jig doctorprints the lines for your.claude/settings.local.json. Codex is not supported; in the desktop app and IDE a permission prompt sends after about 6 s even while you are there;$CLAUDE_PROJECT_DIRin a real hook is unmeasured. See When an ordinary session waits for you. - A task carries its tracker issue. New project key
task.issue_pattern([A-Z][A-Z0-9]*-[0-9]+, or[0-9]+) reads the issue from the start of a task id;jig task shipputs it into the commit’s first line and the pull request title. See Tasks from a tracker. - The pull request names the linked sources a task edited. The autopilot report and its pull
request carry a Changed linked sources — need your review block, also printed by
jig knowledge changed --to-review(a new flag); it stops nothing. See The report.
0.25.1 — 2026-10-10
- A merged branch whose remote copy someone else removed is deleted too. When the hosting site
deletes a branch on merge and another tool — an editor’s background
git fetch --prune— then removes itsorigin/copy,git branch -drefused the squash-merged branch and housekeeping kept it (kept branch <name>: git does not see all of its commits merged). Now such a branch goes when its last commit is the one the hosting site merged, or an earlier one; a branch with anything newer stays, as before.
0.25.0 — 2026-10-09
Autopilot can tell you, in Telegram, when a run needs you or is done. Nothing changes until you set it up: with no token and chat id, no message is sent and no command behaves differently.- Messages in Telegram on autopilot stops and ends. A run that stops, ends, or — unattended —
approves its own design or decides something for you sends one short plain-text message: a mark
(
⏸waiting for you,⛔stopped unattended,✅ended,🤖chose for you), the project and the task id, the task’s description, the reason, and onendthe pull request link. Sending runs in the background with a ten-second limit and never holds up or fails the command; with nocurlit is skipped. See Messages in Telegram. jig notify setupandjig notify test.setupis run by you, in your own terminal: it asks for the bot token with hidden input and for the chat id, writes them to your gitignored.ai/config.local.yamland sends a test, so the agent never sees the token.testsends one message and prints Telegram’s answer when it fails;jig-setupasks whether you want messages and runs the test from the agent’s own session.- New local keys
notify.telegram.token,notify.telegram.chat_idandnotify.autopilot(falsepauses the messages). The token is shown as********byjig config show,jig notifyandjig status;jig config setrefuses it and points atjig notify setup. A token found in the committed.ai/config.yamlis ignored, andjig statustells you to revoke it. jig statusreports failing messages. Anotify:line names the reason and the task while the latest send failed; a later successful message clears it.jig task autopilot <id> endtakes an optional--reason, which becomes the message’s text; without it the message says the run ended, never that it merged.
0.24.0 — 2026-10-08
Two things change what Jig does on your machine. Autopilot runs can ship at a Git level of their own, and a project that declaresverify.full_run: ci no longer runs its full test set or lints
its whole tree locally, in any profile. Read From 0.23.0 to 0.24.0
before you upgrade a project that sets verify.full_run: ci.
autopilot.gitgives autopilot runs a Git level of their own. New key, with the same levels asagent.git(none,commit,push,pr,merge) and local only: it is read from your own.ai/config.local.yaml. Not set, it isagent.git, so nothing changes until you set it. Withagent.git: prandautopilot.git: mergethe tasks you take step by step stop at a pull request for you, and a task on autopilot merges its own.jig task shipgoes by it for a task whose autopilot run is on, or was stopped in an unattended run (its draft); an attended run that stopped, and every ship outside a run, go byagent.git.jig spec shipgoes by it whenautopilot.unattendedis true, the one case an epic’s finish merges, andrelease.merge: humanstill wins.jig upgradeandjig doctorkeepagent.git; housekeeping reads both keys (next entry).- Jig says which level it went by.
jig task shipandjig spec shipprintgit level <level> (<key>),jig task routeandjig task autopilot startprintautopilot git: <level> (<key>), andjig statusprintsautopilot.git: <level> (from <key>). A value Jig does not understand is refused byjig config set,jig task shipandjig spec ship, and named as invalid byjig task route,jig task autopilot startandjig status; it never falls back to another level.jig-setupasks about it, after the question about merging. - Housekeeping deletes a merged branch on
originunderautopilot.gittoo. It used to do so only for a person whoseagent.gitwaspushor higher, so a run that pushed underautopilot.git(withagent.gitatnoneorcommit) left its branch onoriginfor good. Nowagent.gitorautopilot.gitatpushor higher is enough; every other condition for deleting onoriginis unchanged. - Under
verify.full_run: ci, a narrowedjig verifynever starts the full test set, in any profile. Before, only the shell profile read the setting, and even it ran the full set for a change that selected everything. Now every built-in profile runs the tests it can name and says what it left out:laravel: artisan test: skip (scope: routes/web.php can affect any test, full set left to CI), thenverify: 1 check(s) left their full set to CI (verify.full_run: ci); jig verify --full runs it here. A run where nothing else ran saysthis run verified nothing here.jig verify --fulland a non-emptyCIenvironment variable run everything, as before.--explainno longer promises a full set underciin the go, node and python lines. - Under
verify.full_run: ci, the linters and static analysis check the changed files too.phpstan,pint,ruff,eslint,rubocop,shellcheck,go vet,cargo clippyanddart analyzecheck only what changed. Where the whole tree would be checked, the check is left to CI withskip (scope: …, full set left to CI): when the tool’s configuration changed (phpstan,ruff,rubocop,eslint,mypy,shellcheckon.shellcheckrc), when pubspec or the solution changed (dart analyzeandformat,dotnet format), on a workspace-wide or module-wide change (cargo fmtandclippy,go vet), and always fortscandswift build, which cannot narrow.mypynow checks the changed files, where it checked the whole tree; checked alone, a file can miss what it breaks elsewhere (CI finds that), and a file named on the command line bypasses mypy’sexclude. Withoutverify.full_run: cinothing changes.
artisan,
mypy, go, cargo, npm and the others) played by stand-ins; they were not run against a real
Laravel, Python, Go, Node or other project. The ci decisions are tested for the laravel, python, go,
node, php, ruby, rust, dart, dotnet, jvm, swift and shell profiles. Not run against a real GitHub or
GitLab repository. The installer did not change since 0.23.0, so the Windows release checklist does
not apply to this release.
0.23.0 — 2026-10-07
A branch Jig made no longer stays behind once its work has landed: Jig deletes it, here and on the remote, right after a merge it made itself and in housekeeping. The first housekeeping run after this upgrade may delete many branches at once, so read From 0.22.0 to 0.23.0 before you upgrade a clone that has collected them.- Jig deletes the branches it made once their work has landed. Which are its own:
jig/upgrade-*,finish/<id>, and the namegit.branch_templategives a task id (when the template has literal text before{id}); never the base branch,epic/*,spec/*or a branch you made yourself. It deletes locally withgit branch -d, never-D, so Git itself refuses a branch holding a commit that is nowhere else; on the remote it pushes the deletion with a lease at the commit that was merged, so a branch somebody pushed to afterwards stays. A branch with an open pull request, as its head or as the base of another, a branch checked out in any worktree, and the branch of a task workspace that is still in place are kept. - After a merge Jig made, you are back on the base branch and the branch is gone.
jig upgradeandjig task shipatagent.git: merge, and the final merge ofjig spec ship, now switch the main checkout back to the base branch, fast-forward it toorigin, and delete the branch here and onorigin(upgrade: back on main,upgrade: deleted branch jig/upgrade-0.23.0,upgrade: deleted branch jig/upgrade-0.23.0 on origin). If you started from another branch, one more line says how to go back to it. A task shipped from its own worktree keeps its branch until housekeeping removes the worktree after the task is closed, and takes the branch with it then. When Jig cannot delete a branch it sayskept branch <name>: <why>and leaves it to you. Without a hosting site Jig does not merge, so it does not delete. - Housekeeping deletes the branches of finished work. After its task loop, in the clone’s main
checkout, it removes the branches Jig made whose work has landed: a merged pull request (the
hosting site’s answer, the only way a squash merge shows) or the branch being contained in the
base branch. On
originit deletes only for a person whoseagent.gitispushor higher, only with a merged pull request, only while the branch is still at that pull request’s head, withhousekeeping.fetchnotfalse, and (on GitHub) the pull request has to be among the last 200 it lists.jig housekeeping --dry-runprints what it would delete aswould delete branch <name>. Its fetch now passes--no-prune, whatever yourfetch.prunesays: the copy of a branch onoriginis whatgit branch -dcompares a squash-merged branch against, so it is dropped only after its local branch is gone andoriginno longer has it. git.delete_merged_branchesturns it off. New key,trueby default, a local key, so your own.ai/config.local.yamloverrides the project file:jig config set git.delete_merged_branches false --localkeeps every branch and leaves you on the upgrade or task branch after a merge Jig made.- The upgrading page has a step-by-step “After an upgrade” section. From
jig self-updateto a project back at work, in order: the clean start, what eachagent.gitlevel leaves to you, the manual steps, skipped releases, branches in progress, restarting your agent’s sessions, thejig doctorandjig statuschecks, and what colleagues do. It also lists the refusals an upgrade can end in and what to do.
gh and
glab answers played by stand-ins. The tests cover deletion where it must happen (an upgrade, a
task ship that merged and one that squashed, GitLab, a spec’s finish branch, housekeeping by
containment and by a squash merge on the hosting site) and keeping where it must not (the key off, not
merged, shipped from a worktree, not a Jig branch, the base, an epic, a spec, a live task and its
base, an open pull request, origin moved after the merge, agent.git below push). Not run against
a real GitHub or GitLab repository. The installer did not change since 0.22.0, so the Windows release
checklist does not apply to this release.
0.22.0 — 2026-10-06
At a terminal,jig doctor, jig upgrade, jig status, the installer and jig-setup now say what
needs you first and group the rest, jig status reads by section and groups tasks by spec, and an upgrade no longer refuses because of a session that only
looked around.
Everything below about a terminal is only the terminal. In a pipe, in CI and in an agent’s shell the
output of doctor, upgrade, status and the installer is what it was: tests compare the whole
report of doctor, upgrade and status with the old text, and install.sh’s main runs (a
successful run with the PATH advice, the other-checkout note, an error). install.ps1’s plain form
is held by line-level assertions in every scenario, not by a whole-output comparison. jig-setup is
the exception: it is a skill, and it speaks in blocks wherever it runs.
jig doctorat a terminal lists what needs you first. Failures, then warnings each with its fix, then every passing check in one line (ok 13 passed: git, ...), then the tally. The exit code does not depend on the form. The terminal form waits for the release check (up to 5 seconds) before it prints; the piped form still streams each check as it runs.jig upgradeat a terminal says what changed, not every file. Replacements are grouped into one line per verb (ok replace 50 file(s): .ai/scripts (14), .claude/skills (17), ...); installs, deletions and links stay one line each, and every file the upgrade kept is awarnline. Measured once, on a project installed from v0.18.0 and upgraded on a real pseudo-terminal, 58 files placed: 66 lines before, 17 after. A run that dies midway names none of the files it had replaced at a terminal; the repeat that finishes it reports them as already placed.jig statusat a terminal reads by section. A heading that ends in the verdict, then Needs you (only when something does, each item with itshint:,fix:orsee:line), Install, Settings, Tasks, Knowledge & specs and Recent activity here, one row per item in aligned columns, none wider than 80 columns (a longer row continues on the next line). Related settings share one row, activity is folded by command and hour, and the last row says which task holds HEAD here, or that nothing does. The rules and marks are drawn with─,·and…on a terminal whose locale is UTF-8 and with-,|,.and...otherwise; titles are bold cyan, the verdict is green, yellow or red, andNO_COLORorTERM=dumbremoves colour and keeps the sections. Measured once, on a fixture shaped like a busy project (10 active and 12 finished tasks, 24 activity records, 11 settings): the plain report is 59 lines; an intermediate grouped form of this release was 18 lines that wrapped to 31 rows at 80 columns, and the sectioned form is 41 rows, none wider than 80.jig doctorand the counts the status page caches (status-counts) are unchanged.- Tasks in
jig statusare grouped by epic and spec. At a terminal each epic comes first, then each spec without an epic, with the progress of its roadmap (Release 0.20.0 (epic · 3/5 done)) and the tasks hung under it as a tree; tasks that belong to no spec come last under “Other tasks”. A task linked to two specs, or to a spec that is not here, is listed under “Other tasks”; when no task belongs to a spec the section stays flat, as before, and a spec with no task is not drawn. The tree uses├─and└─(|-and`-in ASCII). For an epic that is not checked out here the progress is read from the epic’s branch, and shown as just “epic” when that branch is not here. The status page groups its “Running now” tasks the same way, each group with its spec, a kind badge and a progress bar. The piped report is unchanged. - The installer speaks the same blocks.
install.shandinstall.ps1print a level word (ok,warn,fail, andaskfor a question) padded to six columns, with the PATH advice and the other notices before the closingok jig installed: ...; an error is afailblock. The PowerShell installer colours through the console (okgreen,warnyellow,failred,askcyan), never through escape codes, and runsjig doctorin its grouped form without colour.jig-setupasks and reports in the same form. - Output switches.
JIG_TERMINAL=1forces the terminal form andJIG_TERMINAL=0the plain one;NO_COLOR(any non-empty value) andTERM=dumbremove colour and keep the grouping. A reader that needs the old text under a terminal setsJIG_TERMINAL=0. - An upgrade refuses only where a started task holds this checkout’s branch.
jig upgradeused to refuse because another session had runjig statushours earlier, orjig task showon a task not checked out here, and the only way out was deleting a file the message did not name. It now refuses only when you are on the branch of a started, unfinished task (the upgrade would take the checkout off it); the message names the task, its branch and the way on:jig task start <id> --worktree, then the upgrade again, or, inside the task’s own worktree, the upgrade in the main checkout. A session that only looked around no longer stops it.jig task startandjig upgradenow answer “who occupies this checkout” with one rule.jig verifyrunning here still stops an upgrade. - The upgrade’s “run it in the main checkout” advice is right for a worktree of a bare repository. The upgrade asked Git directly whether it was in a linked worktree and, for a worktree of a bare repository, pointed at a main checkout that does not exist; it now asks the way the rest of Jig does.
upgrade was
measured on a real pseudo-terminal, and that of status on a fixture, a stand-in for a busy project; on Windows CI only proves that
JIG_TERMINAL=1 jig doctor runs in Git Bash and that the shards pass (the byte-for-byte doctor test
skips there). Not proven by anything kept: that the colours render in Windows Terminal or the Windows
PowerShell 5.1 console, that ask and the typed answer share one line there, and that the
home-folder refusal reads as an instruction. The Windows release checklist was not walked on a real
machine for this release.
0.21.0 — 2026-10-05
A task can no longer be finished past a stage its class asks for, an epic finishes without a push to the epic branch, and your agent can hand writing and reviewing the code to a helper on a model you choose.- A task whose route skipped a recorded stage is refused.
jig task set <id> status ready,jig task set <id> knowledge_consolidated trueandjig task shipread the class’s full route and refuse when a stage that leaves a record left none, naming what is missing and the command that writes it: the approved design for T3 and T4 (the approval must still matchdesign.md),spec.mdandalternatives.mdfor T4, a review receipt for the review of T2 and up and for the architecture review of T3, andstatus ready, verification’s own sign-off, before consolidation and shipping. A lighter route (route.depth: lean) trims none of this, and a task filed with this version and given no class is refused. A task filed before this version is not refused: it gets the same list as a warning and finishes under the rules it started with. A review receipt now remembers every stage it was written for, so a re-review under another stage does not erase the first. Proven by tests on throwaway repositories that run both directions; no run on a real project is kept. - Lowering a class needs a reason, and an unattended run cannot lower a risky one.
jig task set <id> class T1 --reason <text>records the reason and the class it came from, andjig task route,jig status(lowered=T3), the status page and the autopilot report show it. Where nobody answers (an unattended clone or run), a task cannot be lowered below T3 out of T3 or T4. Raising a class is unchanged. - An autopilot run cannot resume itself.
jig task autopilot <id> resumenow needs--answer <the human's answer>, which is journaled and printed in the report under “Resumed on an answer”; in an unattended runresumeis refused, andendthere requiresknowledge_consolidated true, so a run cannot reset its repair limit by ending and starting again.jig task gate <id> approvedwithout--by agentis refused wherever nobody answers: in an unattended clone, whether the run is not started, on or stopped. In an attended clone nothing changes. - A planted link cannot send a task’s files elsewhere. A link planted on
.ai/workspace,.ai/workspace/tasksor a task’s own entry used to slip past the check ofjig task artifact writeandappend(a plantedtaskslink wroteplan.mdoutside the repository with exit 0). Every command that writes into a task workspace,jig task new,jig spec linkandremoveand housekeeping included, now follows the link to where it leads, symbolic link or Windows junction alike, and refuses unless that is this checkout or a worktree Git lists for this repository. The linksjig task start --worktreemakes and a coordinator’s own.ai/workspacelink keep working. The junction case was exercised by tests that plant links the way Windows CI does, not by hand on a real Windows machine. - An epic finishes without a push to the epic branch.
jig spec epic --finishand--reopenrun on the epic or on a branch cut from it, and the finaljig spec shipcutsfinish/<id>from the epic, commits the spec’s removal and the version bump there, and opens the pull request into the default branch from it. The epic is never pushed after it is cut, so a repository that protectsepic/*like the main branch needs no bypass; theepic-prcheck accepts afinish/<id>head. See Agent ships. - New personal setting
release.merge.agent(the default) keeps today’s behaviour: an unattended run atagent.git: mergemerges an epic’s final pull request once CI passed.humanopens it and leaves the merge to you. Local only, set withjig config set release.merge human --local; task pull requests are not affected. See Configuration. - Hand writing and reviewing the code to a helper on a model you choose. Two new personal settings,
claude.implement_modelandclaude.review_model(set by hand or through a newjig-setupquestion), name the model a helper agent in Claude Code uses for the implementation and for every review of a route;jig task route <id>prints adelegate:line for each stage that will be handed over. Jig carries the name as written and never checks it. With nothing set, the default, nothing is handed over and every route runs as before; in Codex the settings are ignored. The helper’s findings and receipts count like anyone’s: the checks still have to pass. Proven by tests of the settings and of thedelegate:lines; no run of a helper on another model is kept as a test. See Autopilot. jig-verifyno longer leaves a log in your working tree. The skill used to tell the agent to redirectjig verifyintoverify.login the project; the report now goes to the terminal.
0.20.0 — 2026-10-03
A started task can be moved into a worktree of its own, a worktree can share a folder of packages with its checkout, a person can choose a lighter route, and an agent can plan a release.- A task that has already started can move into its own worktree.
jig task start <id> --worktreeon a started task (withgit.branch_per_taskon) used to refuse with “already started”; it now frees the branch in this checkout, adds the worktree on it, links the workspace and carries the declared state. Commits made so far stay on the branch. It moves nothing that is not safe to move: when this checkout holds its branch and has uncommitted changes to tracked files it refuses and namesjig task pause <id> --stash, and the checkout goes back to the task’s base branch; every refusal comes before anything changes, and a failure afterwards puts the checkout back on the branch. The branch is never deleted. Moving back out of a worktree stays with Git. The “HEAD moved” notice now names this command. This was tried in tests on throwaway repositories. - New setting
worktree.share. For a project that keeps separate repositories under edit beside its code (apackages/folder, Composer path repositories):worktree.share: [packages]gives each task worktree a realpackages/folder in which every entry is a link (a junction where symbolic links cannot be made) to the package in your main checkout. There is one copy of each package, and removing the worktree, by Jig’s cleanup or bygit worktree remove, removes the links and never the packages. A test makes a commit and leaves an uncommitted file through the worktree, removes it with a baregit worktree remove, and finds both in the owner’s checkout; the same steps withcarry, tried by hand on 2026-09-24 and not kept as a test, lost the commit. The folder must be in.gitignore; a package added later is linked in byjig task bootstrap <id>; a path declared as bothcarryandshareis shared. Jig refuses a shared folder that is itself a Git repository. The known issue about removing a carried worktree by hand is gone, and Working with tasks says how to set it up. The junction path is exercised by the Windows CI job, not by hand on a real Windows machine. - New personal setting
route.depth, andjig task route.route.depth: lean(set withjig config set route.depth lean --local; the default isfull) lets you run less of a class’s route: a T1 analysis is a few lines intask.md, a T2 plan is part of the analysis, and T2 to T4 run one review round, with P2 and P3 findings left open and listed in the pull request. Tests on changed files, CI before a merge, consolidation, the T3/T4 gate and architecture review, a re-review of a fixed P0/P1 and the task’s class are never trimmed. A value in.ai/config.yamlis ignored and reported, as foragent.git. For one task:jig task new <id> --lean, orjig task set <id> route_depth full|lean; the task’s own value wins.jig task route <id>prints the class, the depth and where it came from, the route and what lean trims.jig statusmarks a lean taskdepth=lean, the status page badges it, andjig task autopilot startandreportprint the depth. See Concepts. jig-release: an agent can plan a release. A new skill (placed byjig upgrade) looks at the filed tasks and open specs, proposes what goes in, in what order and at what version level, and, once you agree, builds the release as a spec with an epic.jig spec link <spec-id> <task-id>links a task filed earlier (it refuses a started one, a closed one, or one linked elsewhere), andjig task list --goalsprints the first paragraph of each task’s goal under its line. See Skills. The skill was proven by its tests and by being used for this release; it has no run of its own beyond that.- A review stays valid when the base moves. The review receipt used to pin the whole working tree, so
merging the base into a task branch made it stale even when the task’s own change had not moved. It now
compares four things by content: the task’s own change against its merge base, the knowledge
jig contextresolves for that change (without the knowledge the task wrote itself), the approved design and the findings. The stale message says which part moved. A receipt written before this version is compared by the working tree until the next review rewrites it. Two consequences to know. An unrelated merge that edits a global knowledge document (the glossary, the architecture, the rules), or a document that applies to the files the task changed, still makes a receipt stale, becausejig contextreturns those. And every receipt check now resolves that knowledge, whichjig status, thereadystatus andjig task shipall run, and the cost grows with the known issue thatjig contextis slow on a large project.jig statustherefore no longer resolves it: it compares the change, the design and the findings, and for a receipt that still matches saysnot checkedrather thancurrent;jig task receipt --check, thereadystatus andjig task shipstill check everything. Measured on five tasks that each had a receipt and a worktree,jig statustook 51 s with the check on every task and 9 to 11 s without it. The roadmap entry for this is gone. - Skills write a task’s own documents through
jig task artifact. The command takes three more kinds,knowledge-map,commit-messageandpr-body(the files arecommit-message.mdandpr-body.md), sojig-consolidate,jig-mapand a phase run no longer write them with a shell redirect, whichjig-taskforbids.jig-reviewandjig-architecture-reviewkeep the list of changed paths in a shell variable instead of a workspace file.
0.19.0 — 2026-10-02
jig verify now knows the common local PHP environments, runs every built-in profile where your
project runs, and jig doctor says when this machine’s runtime is not the one your project asks for.
- More environments are recognised, so fewer projects are refused. DDEV (
.ddev/config.yaml, throughddev exec --raw), Lando (.lando.yml) and a devcontainer (.devcontainer/devcontainer.json, through thedevcontainerCLI when it is installed, otherwise the labelled container) now have detectors; Lando and a devcontainer without its CLI are reached withdocker exec. A stopped one is refused with its start command (ddev start,lando start,devcontainer up); a shell already inside one of them runs on the spot. Jig still refuses a.devcontainer/or.ddev/folder without its manifest. Devilbox is found by its PHP container (compose servicephp, data folder mounted at/shared/httpd) wherever your data folder lives, and its checks run there as Devilbox’s own user. Laravel Herd is found when the project is one of Herd’s sites; its checks run on this machine with Herd’sbinfolder first onPATH. Devilbox’s detection was tried against a real running stack (the container was found andphp -vran through the prefix); a fulljig verifythere, and its refusals, were exercised only with stand-ins. DDEV, Lando, the devcontainer CLI and Herd were exercised only with stand-ins for their commands and fixture files, never a real install; if one is not recognised or answers wrongly,run.execandrun.pathoverride it (Configuration). - New personal setting
run.path. A folder put first onPATHfor the checks when they run on this machine, for a PHP that is not first there;auto(the default) uses what Jig detected (Herd’s). Blanks are allowed in it; it must be an absolute folder that exists, and a missing one is refused. - Every built-in profile runs where your project runs. The
shell,python,go,rust,ruby,jvm,dotnet,dartandswiftprofiles joinedphp,laravel,nodeandgeneric: inside an environment their checks go through its prefix instead of being skipped. Under an environment, Python does not use the$VIRTUAL_ENVor poetry of this machine; its tools come from a.venv/orvenv/that runs there, otherwise from the environment’s ownPATH. This was tested with a stand-in fordockerwhose tools exist only inside the “container”, not in real containers. jig doctorandjig verify --explainwarn when this machine’s runtime is not the one your project asks for. When the checks run on this machine, Jig compares the PHP, Node and Python found here withrequire.phpincomposer.json,engines.nodeinpackage.jsonand.python-version. Common forms (^,~, comparisons, wildcards, “and”, “or”) are judged; any other form is reported as “could not compare”, never as fine, and so is a runtime that is not installed on this machine.jig doctoralso lists the runtimes that match;jig verify --explainprints only the warnings. Nothing is said when your project asks for nothing, or when the checks run in an environment. These are warnings: they do not stopjig verify.jig task startrefuses less often. Only a task that has been started, is not finished, and holds the branch checked out in this checkout now counts as working in it. A session that only filed a task withjig task newor ranjig statusno longer blocks the next start. The refusal andjig upgrade’s matching stop no longer advise deleting the other session’s record: it lapses by itself aftercheckout.busy_ttl.- Paths with a backslash no longer confuse container detection. The container reader now passes
project paths to
awkin a way that keeps backslashes as they are.
0.18.0 — 2026-10-02
jig verify learns to run a project’s checks where the project runs, and Jig stops leaving its
scratch files behind.
jig verifyruns the checks where your project runs, and refuses rather than guess. Before any check, it decides once whether the commands go to this machine or through a prefix that reaches your container, and says so —verify: checks run in <where>— with--explain, and whenever the checks go through a prefix. Laravel Sail and a docker compose service that mounts the project are recognised on their own; the new personal settingrun.exec(auto,host, or the command that reaches the container, written in plain words with no quotes,$or backslashes) overrides what Jig found. When there are signs of a container no detector recognises — two compose services mounting the project,DB_HOSTnaming a compose service, a.devcontainer/,.ddev/or.lando.yml— Jig exits 3 and names what it saw instead of running the checks on the host; a stopped container, or one that mounts another checkout than the task’s worktree, is refused the same way. Thephp,laravel,nodeandgenericprofiles run through the environment; when checks run in one, a profile not yet adapted is skipped with the reason, never run on the host. WithCIset andrun.execleft atauto, nothing is detected and nothing is refused. Thejig-setupskill now asks where your tests run, as its eighth question (Configuration, Troubleshooting).jig task startrefuses a checkout another session is working in. It reads the record every Jig command already writes in the checkout and, when other work is live there, stops and names the owner, how long ago it ran, and the ways out: start in its own worktree (--worktree), wait, or delete the record if that session is over. There is no override. It does not apply to--worktree, to a project on one branch, or to records of tasks that are consolidated or abandoned, or whose branch is no longer the one checked out.- An interrupted Jig command removes its own temporary files.
Ctrl-C(SIGINT) and SIGTERM now end a command with exit 130 and 143 and run its cleanup, and the temporary files and folders Jig makes are removed when the command exits or is stopped by either signal — the*.tmp.<pid>files that used to pile up beside your project’s files. A command killed with SIGKILL cannot clean up, and a closed terminal is not caught either. The test runner no longer leaves itsjig-*folders in your temporary directory (more than 4,600 had piled up at once). - A shared shell library change narrows what
jig verifyruns. With theshellprofile, a change to a script that has no test file of its own (scripts/lib/common.sh, say) now runs the tests of the scripts that call the functions it edited, instead of the whole suite. When it cannot name them — a changed global, asource, a new or removed function or file, a function nobody calls, a caller with no test — it still means the whole suite. Withverify.full_run: ci, that whole-suite part is left to CI when filters ran beside it, and the line says so:scope: N filters, full set left to CI. load: domainknowledge reaches the files it names. A document withload: domainwas required only when its domain was entered; itspathswere ignored.jig contextnow requires it for a matching domain or a matching file, so an agent editing a file a domain pack names gets the pack without passing--domains. Cached answers made under the old rule are not served.- The status page redraws after knowledge commands.
jig knowledge new,paths,reviewed,acceptandrejectnow refresh thejig status --htmlpage they changed, so its proposal and changed-source counts are no longer stale until the next task command.
0.17.1 — 2026-09-30
No change to how Jig behaves. One test of 0.17.0’sjig doctor latest release line was wrong on
Windows: it rejected any output containing “available”, and Windows prints
directory links: junction (symlinks unavailable). The test now checks only the latest release
line, and the release’s test suite passes on Windows again.
0.17.0 — 2026-09-30
jig upgrade becomes a change of its own, and the installer and Windows checkout gain the fixes
0.16.1 was too small to carry.
jig upgradenow runs as its own change, on its own branch. It checks first that it may start — no uncommitted changes, nocore.autocrlfwithout Jig’s files pinned to LF, no other session orjig verifybusy in this checkout — then works onjig/upgrade-<version>, cut from your base branch, and commits once the result checks out. It ships as far as your agent’s git rights allow, the same asjig task ship(Upgrading). The commit and its pull request now also carry a checklist of the manual steps left between your version and the new one, instead of a fixed pointer at this page.jig doctortells you when a newer Jig has shipped. Itslatest releaseline asks the tool’s own origin for the newest published tag, instead of only comparing your project against the copy on your machine — so the two can agree and still both be behind. It tells apart a real “you’re behind” from “could not check” (no network, no origin, no answer in time), and never reports either as “up to date” by mistake (Upgrading).jig statusshows a newer Jig release too, without runningjig doctorfor it. Housekeeping now checks the same thing once a day in the background and keeps the answer;jig status(plain text and the--html/--openpage) reads it offline and, the moment a newer release is out, printsjig v<X> is out — jig self-update, then jig upgrade. No network call of its own, and nothing shown when there is nothing new or the check failed.- The Windows installer no longer refuses a drive or share root that is already your
repository. A
substdrive, a volume kept for one project, or a\\server\sharethat is itself the top of an existing repository now installs the project too, not only Jig (Known issues). - A Jig project cloned on Windows keeps taking upgrades. Line endings are now pinned for all
of
.ai/manifest,.ai/scripts/**,.ai/profiles/**,.ai/templates/**and both adapters’ skill directories, not only the scripts — a clone or task worktree made with Git’s defaultcore.autocrlf=trueno longer reads its own manifest as empty (Upgrading). jig housekeepingno longer hangs waiting for a credential prompt nobody can answer. Every networkgitcall it andjig self-updatemake now refuses to prompt, so a remote that would otherwise ask for credentials fails fast instead of piling up one stuck process per session.- A task can no longer be closed while its pull request is still open.
jig task set <id> status consolidatednow checks with the forge first and refuses unless the pull request has actually merged, so a task does not disappear fromjig statuswhile it still needs a merge. jig verifytells a change no check covers from missing tools. A documentation-only change used to refuse with “install the project’s tools”, even though the tools were already there. It now recognises a skip explained by scope and passes instead of blaming your setup (Known issues).- The front-end cut now reaches Python, Ruby, Dart and Node projects. A stylesheet, image or front-end source file that a project’s own test suite cannot observe no longer forces the full set to run, the way it already worked for PHP and Laravel — each stack keeps its own build and fixture exceptions, and the reason now names the file that forced a full run.
jig contextandjig knowledge checkare markedly cheaper on a real repository. One shared tree walk replaces a filesystemfindper path pattern of every document (291 finds down to one walk, on an 83-document project measured at 30-39s before the fix); a task’s repeatedresolve/guardcalls with the same selectors now reuse their answer instead of recomputing it, measured at roughly 6x faster (about 8s down to about 1.3s on an 89-document project) (Known issues).- A second session on a spec no longer leaves it sitting dirty on your default branch.
jig spec newand the newjig spec resume <id>switch to the spec’s own branch first, the same branchjig spec shipalready used;jig task start’s dirty-tree refusal now namesjig spec shipwhen every uncommitted change belongs to one spec. - The status page’s own redraw no longer swallows a neighbouring session’s “HEAD moved” notice.
Refreshing
jig statusrunsjig statusagain as a subprocess; that subprocess is now marked internal so it cannot consume a checkout notice meant for another session. - A reason or note you type is stored exactly as typed.
jig task pause --reasonand similar free-text values could have a backslash sequence reinterpreted on the way into the task’s state file — a Windows path likeC:\tempno longer risks being mangled or splitting into a second, bogus state line.
0.16.1 — 2026-09-28
Fixes to what 0.16.0 shipped: the Windows installer,jig upgrade, and how much a PHP project’s
checks run.
- The Windows installer no longer turns your home folder into a Git repository. Taking its
defaults from a fresh PowerShell used to make your whole profile a repository and commit
everything in it. It now refuses your home folder, any folder above it, the root of a drive and
a folder inside another Git repository, and
-Yesdoes not change that. Asked interactively, it says why and asks for another folder; Jig itself is installed either way (Install). - It also refuses a folder it should not, which 0.16.0 accepted: the root of a drive or a
network share that is itself the top of an existing repository — a
substdrive, a volume kept for one project,\\server\share. Jig is installed, only the project step stops; runjig initin that folder yourself (Known issues). - An interrupted
jig upgradeis finished by running it again. A file that already holds the new version is recognised as placed, reportedalready-placed, and no longer mistaken for your edit. A project an earlier interruption left in that state heals on the first run of this version, with nothing to reconcile by hand. jig upgradesays what it left undone. At the end of a run it asks the install it has just made whether anything is still missing, names it, and tells you to runjig upgradeagain — instead of leaving it forjig doctorto find a day later.- Repositories with SHA-256 object names, or with clean filters, upgrade properly. Every
framework file used to read as modified in the first kind, and the filtered paths in the
second, so those files stopped being updated. Upgrade with
jig self-updateandjig upgrade; if your agent runs the project’s own.ai/scripts/jig upgrade, these two kinds of project need one more step (Upgrading). - A front-end change in a PHP or Laravel project no longer runs the PHP test suite. When a
scoped
jig verifydoes run the whole suite, it now names the file that caused it —scope: package.json changes the asset build, which browser tests load, ran full setinstead ofscope: not narrowable, ran full set.
0.16.0 — 2026-09-25
Green now means green.- A pass now means something was checked. Two states used to be one. A project whose stack a
profile covers, but whose tools are missing, is refused (above). A project no profile covers
is not blocked — there is nothing to install and nothing to wait for — but it is not called
okeither:jig verifysays nothing here checks this project and exits 0, andjig task shipsays it again as the change leaves your machine. jig task shiprefuses instead of shipping nothing. An empty index with unstaged changes used to print a note and carry on — pushing the branch and opening a pull request with the change left behind, where nothing makes CI red. It is now an outcome, not information. An empty index with a clean working tree still proceeds: that change was committed by an earlier run.- Two verifications no longer fight for the machine.
jig verifywaits for one already running in the same clone and says how long it waited (verify.busy_ttl: 0turns the wait off). A run that was killed — out of memory, an overloaded machine — reports incomplete and exits 3 instead of counting as a pass. jig verify --explainsays what a run will expand to, before it runs. One line per check —full,filtered,skiporconditional— so you can see that a change to a widely-used file means the whole suite before you start it. It takes no busy record, runs no project tool and produces no verdict (Manual control).- A task worktree is a place you can actually work in.
worktree.carrycopies the state Git does not track —vendor/,node_modules/,.env— into a new worktree, beyond what the active profiles already declare (Configuration). And removing a worktree now asks every Git repository inside it first: a clone holding work that exists nowhere else keeps the worktree rather than going with it. - A task filed from inside a worktree no longer disappears with it. A worktree borrows its checkout’s whole task directory rather than the single task it was made for, so a task an agent files while working in one is visible from the main checkout and survives the worktree being removed. Measured on Windows too, where the borrowed directory is a junction.
- The status page stopped saying what it cannot know. It keeps your place across its own auto-refresh, reports what it actually knows about a pull request instead of inferring it, drops a card the disk has already disproved, and shows the pull request of a task whose autopilot stopped.
- Several sessions in one checkout see each other. Every run records in the checkout’s
gitignored
.ai/runtime/that work is happening here;jig statusgains aworking here:line for each live record, and the commands a session orients itself with warn it, on stderr, when HEAD moved underneath it. jig upgradekeeps your instructions current. For a project that has made the claim above, it refreshes the Jig section of yourAGENTS.mdinstead of leaving it on the version it was written for, and no longer replaces a Windows project’s CRLF line endings with LF when it does.jig statusalso reports the config keys your.ai/config.yamlno longer mentions — capabilities a new version brought that nobody offered you.- Jig acts on the repository you ran it in.
GIT_DIR,GIT_WORK_TREEand the other variables that choose what git acts on are cleared, so jig started from a git hook or an editor that exports them no longer writes its records into another repository. - New pages: Upgrading, what an upgrade does for you and what it leaves to you;
Known issues, faults in Jig itself and what to do instead; and
What’s next, the order the open ones are being fixed in.
schemas/profile.mddocuments the keys ofprofile.yamlfor anyone writing their own.
0.15.1 — 2026-09-23
- Fix:
jig upgradein copy mode replaced.ai/scripts/jigby rewriting it in place — the file the shell was running at that moment. Once the new dispatcher was longer, the shell read on past the end of the version it had started and ran whatever the new bytes said there, ending an otherwise complete upgrade in an error from a line it had never executed. Every file is now written beside its destination and renamed over it.
0.15.0 — 2026-09-23
Agents that finish a task on their own.agent.gitdecides how far a finished task travels by itself — committed, pushed, an open pull request, or merged once CI is green. It lives in your own gitignored.ai/config.local.yaml, and the agent gets there withjig task shipandjig spec ship(Handing over the git work).- Autopilot: the
jig-autopilotskill runs a task’s whole route without waiting between stages and stops only where a human is needed.autopilot.unattendedis for runs nobody is watching — every choice made in your place is written into the pull request (Autopilot). - Review findings are recorded with a severity, and an open P0 or P1 blocks the task from being finished. A review receipt pins the tree that was reviewed, so code changed afterwards has to be reviewed again.
- The new
jig-setupskill asks how far your agent may go, one question at a time, and writes the answers to your personal settings withjig config set --local. jig status --htmlandjig status --openwrite a status page that leads with what needs you — stopped runs, gates, findings, open pull requests.- Fix:
jig upgradeno longer rewrites.ai/manifestwhen it placed nothing. - The ignore template dropped its trailing slashes (
.ai/workspace/became.ai/workspace), so a workspace shared through a symlink is no longer reported as untracked. Existing projects can copy the change into their own.gitignore.
0.14.0 — 2026-09-18
Rough edges, and the first pages of this site.- Jig now says when your own
AGENTS.mdorCLAUDE.mddoes not carry the Jig section — the reason an agent silently ignores the workflow.jig init,jig statusandjig doctorall report it. jig initrecords the repository’s actual base branch instead of assumingmain.- The Windows installer explains, before acting, what it does on your behalf: the package
agreements it accepts, that the Git identity it sets is global, and that the session hook runs
housekeeping at every session start.
-NoSessionHookskips the hook. jig upgraderemoves an orphaned file only inside.ai/or an adapter’s skills folder; anything else is kept and reported.- Smaller fixes:
jig helpdocumentsspec closeandspec epic;jig task startexplains itself in a repository without commits;jig knowledgesuggests near misses for an unknown id; a document with neither domains nor paths no longer disappears from the catalog.
0.13.0 — 2026-09-18
- Component boundaries become knowledge: the skills record what a boundary may, must and must not do as a convention document, and a broken “must not” is a blocking review finding.
jig-initcan set up a project that has no code yet — it carries the architecture, stack and invariants decided in ajig-ideaspecification into the project’s knowledge and turns on the matching profiles.jig-ideaasks for two or three architecture options and a stack before a new project’s spec is written.
0.12.0 — 2026-09-18
- Seven more stacks have a profile: Python, Rust, .NET, JVM, Ruby, Dart and Swift, beside the existing generic, shell, Node, Go, PHP and Laravel ones.
jig verifynarrows check by check: linters run on the changed files, tests only where the stack can tie a source file to its tests, and a change to a manifest, lockfile or tool config runs everything.- Tools are taken from the project’s own environment —
vendor/bin,node_modules/.bin, a virtualenv,bundle exec— never a global copy. A missing tool is skipped and says where it looked. - A project can declare which paths affect which checks in
.ai/verify/<profile>.map. - Changed: a first
jig initturns on every stack it detects, notgenericalone.
0.11.0 — 2026-09-18
- New decision records are named by date —
.ai/knowledge/adr/YYYYMMDD-<slug>.md— so two branches can each write an ADR without colliding on merge. Existing numbered ADRs keep their names and theirADR-NNNNcitations.
0.10.0 — 2026-09-17
- A document linked from your repository now reaches agents: a stub created with
jig knowledge new <type> <slug> --source <path>resolves to the source text injig context, instead of only sitting there proposed. - Drift is visible. A stub records the text that was approved;
jig statuscounts the sources that changed since,jig knowledge sources --diff <id>shows what changed, andjig knowledge reviewed <id>approves it again. jig knowledge new <type> <slug> --copy <path>takes in a rule file Git does not track, and refuses until a secrets scan has been reviewed.jig knowledge adr-conventionreads your team’s own ADR numbering, so an agent writes decision records in your style.
0.9.0 — 2026-09-17
jig spec close <id>closes a specification that has no epic, after listing the leftovers — open questions, unchecked roadmap items — that a human has to move or drop first.jig spec epic <id> --finishnow removes the finished specification instead of marking its roadmap line, and--reopenrestores it from Git history.
0.8.0 — 2026-09-17
Also carries the 0.7.x work, which was never released on its own.- Personal settings: a gitignored
.ai/config.local.yamlholds the keys that are yours rather than the team’s — housekeeping cadence and lifetimes, the worktree root.jig statusandjig doctorwarn if the file is not ignored. - Epic branches: a specification can declare one, and
jig spec epic <id>opens it. Phase tasks are then cut from the epic, so a multi-phase feature reachesmainas one pull request and one release. - Every task records the branch it was cut from, so work landed somewhere else is flagged
wrong-baseinstead of being read as merged. verify.full_run: cilets a plainjig verifycheck only what changed and leaves the full suite to CI.
0.6.0 — 2026-09-16
- Windows support, through Git Bash: a PowerShell installer,
jig.cmdfor runtimes that call Jig natively, and junctions where symbolic links are not permitted. - New
jig doctor: it checks the machine, the project and the agent’s instructions, one line each, with a fix for every warning. - Line endings and executable bits no longer depend on the machine —
jig initmerges the needed.gitattributesrules.
0.5.0 — 2026-09-15
- A document your team already maintains can be adopted where it is:
jig knowledge new <type> <slug> --source <path> --proposedrecords a stub pointing at the file instead of copying it. (Such a document started reaching agents in 0.10.0.)
0.4.0 — 2026-09-15
jig spec done <task-id>andjig spec remove <id>: a task names the specification phase it belongs to, and finishing it ticks the roadmap.
0.3.0 — 2026-09-15
- Specifications:
jig spec newandjig spec list, and thejig-ideaskill that stress-tests an idea and keeps the result as a spec with a roadmap under.ai/specs/. - Claude Code runs housekeeping at the start of a session, through a session hook.
0.2.0 — 2026-09-14
The first release.- One-line install for macOS and Linux;
jig initsets a project up for Claude Code and Codex. - Work is routed by risk, T0 to T4, with a task workspace and a branch of its own, a human gate where the class asks for one, and consolidation at the end.
- Project knowledge with proposals a human accepts, resolved per task by path, domain and stage.
jig verifywith stack profiles,jig housekeepingfor what tasks leave behind,jig measure, andjig self-update.- Ten skills:
jig-task,jig-analyze,jig-implement,jig-review,jig-architecture-review,jig-verify,jig-consolidate,jig-init,jig-map,jig-accept.