Skip to main content
Jig is pre-1.0, so a minor version may change commands, the .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 status shows what is parked and where staging drifts from the main branch. The default stays direct. 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>). From agent.git: pr, jig task ship refuses a change that raises the version until it does, and while the main branch has commits after that one; jig spec ship refuses a feature epic (no Release: line) whose final pull request raises the version. This release is the first one made this way. See Specs and epics and Upgrading.
  • jig refresh brings 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 as landed and no longer counts as waiting for you. jig status --json now 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 --revision and --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 next first, and puts another task ahead only by saying why.
  • A GitHub pull request is reviewed on the diff GitHub shows. jig pr fetch reads 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 next still 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 check puts 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-update place jig-pr-review for you: a link in ~/.claude/skills when you have Claude Code and in ~/.agents/skills when 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 -Uninstall removes Jig’s copy. There is no switch to turn it off yet: a link you delete comes back at the next jig self-update. Coming from 0.43.0 or older, the first jig self-update runs the old updater, which does not place it: run jig self-update once more. In Claude Code your copy wins over a project’s, so jig status says when the two differ. jig pr fetch and jig pr followup now print method: and show:, 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 on knowledge/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 create fails during a ship, the error now ends with the GitHub account Jig asked as and where it came from — including a GH_TOKEN or GITHUB_TOKEN in the environment, with the variable to remove. See Two GitHub accounts.

0.43.0 — 2026-11-11

Jig’s git 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 origin use the account its gh calls 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, at agent.git: push too. A change under .github/workflows needs the workflow scope on that account’s gh token. SSH and a GH_TOKEN in the environment are left as they were. A real push as a second account has not been checked yet. See Two GitHub accounts.
  • jig verify measures a task from the branch it was cut from. Under verify.full_run: ci, a plain jig verify checks 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 from git.base_branch as before; the header names the task (Configure verification).
  • jig upgrade names the pull request it waits for. When the upgrade to this version is already on an unmerged jig/upgrade-<version> branch, Jig asks GitHub or GitLab once: an open pull request is named with its URL and refused as not-merged instead of failed, 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 consolidated cannot learn whether the pull request merged — gh or glab missing, 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 status and jig context read 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 --json kept “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 one gh 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 gh call Jig makes about your project’s repository, and jig gh <args> for your own, runs as the clone’s account: github.account in your .ai/config.local.yaml, otherwise the one account gh holds or the one that may push here. jig status shows which it found. When several of yours may push and the active one is not among them, jig task ship and jig gh refuse and say to run jig config set --local github.account <login>; the agent asks you once. With several accounts signed in it needs gh 2.40 or later, and it never runs gh auth switch. git push over HTTPS still goes as gh’s active account (Known issues). See Two GitHub accounts.
  • Review a colleague’s pull request. Give the jig-pr-review skill 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-idea works 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), and jig status shows a drafts: line while one exists (Keep an idea’s draft). jig spec ship puts 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 status 2024 → 589, jig task current 196 → 46, jig queue next 287 → 108, and jig upgrade --dry-run in 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 file refuses an already filed item with already-filed. already-exists now means only that the --new task id is taken; a program that read already-exists for 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 pause and jig task autopilot stage no longer fail with “cannot take the pause request … out of the queue” when jig queue cancel removed the request but exited non-zero. Under git.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 from main 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 init and jig upgrade, dry runs included, refuse a Jig checkout that is not at the release tag of its version, or that has local changes there, as unreleased-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 records jig.version: 0.41.0+<sha> (+<sha>.dirty from a checkout with local changes), and an upgrade from a released Jig records the plain number again. Off a tag, jig --version and jig status call the version X.Y.Z+<sha>, and jig status says when the global Jig is on the development channel. jig self-update on a branch and install.sh --ref <branch> say the same, and install.ps1 -Ref <branch> asks before it sets up a project from such a Jig (the answer defaults to no). jig verify no longer asks for framework files from such a checkout, and jig doctor warns instead of failing. Link mode is unchanged. How to develop Jig next to a released install is in CONTRIBUTING.md. If your Jig was installed from main, or is a clone you pull, see When the source is not a release.
  • jig context reads knowledge without a process per document. On a repository with 139 documents it takes 0.6 s instead of 8–10 s, and jig task list --json gets 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 is changed, unrecorded or missing, and retires it. In jig knowledge proposed --json and sources --json, every entry carries decidable and a reason (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> --json gives 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 --diff and read answers. 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 in sources --json and sources --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 set puts 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 as stale-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 with branch-has-other-commits after 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 as write-still-waits, and jig writes stops 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, what git worktree remove leaves of Jig’s tree (links, empty folders) is cleared instead of refusing every later write as tree-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-2 when x-2 is a spec); a write without --revision is no longer refused as stale-revision for a write that landed meanwhile; and jig writes ship no longer fails when you deleted the local branch: it takes the branch back from origin.
  • Context acknowledgements say what they stand for. jig context guard names why each pending document is required and at which stage the acknowledgements it accepted were made. jig context acknowledge records the stage and takes --revoke to withdraw a claim (with --stage it 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’s profile.yaml stands that check of the lower profile down when both run, and the run and --explain say who covers it. php, laravel, node and python name their test check tests (checks: [tests]), and laravel covers php:tests: a Laravel project runs its suite once, in php artisan test, with .ai/verify/php.map read after laravel.map. A project profile over a stock one takes its tests the same way. jig upgrade keeps a stock profile you edited, so such a copy goes on as before until you add checks or covers to 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 in jig status and 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.
  • jig ends when it is told to. kill, pkill or 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 after JIG_TERM_GRACE seconds (default 5). This holds on Git Bash too.
  • A forge behind an SSH host alias is found. With origin at git@github-personal:owner/repo.git and the alias mapped in ~/.ssh/config, forge: auto asks ssh -G for the real host, so jig task ship and jig spec ship open pull requests again.
  • An agent’s wait on a check has an end. The jig-verify skill forbids waiting on a run by watching its output for a line, as it already forbade pgrep -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 variable error and ran housekeeping daily whatever housekeeping.cadence said. A task closed from an agent session with --revision was always refused as stale-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 from jig writes. jig upgrade --land no longer calls an upgrade that returns a project to a release landed while origin still 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, and jig 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|file and jig knowledge accept|reject|reviewed --revision <n> --json commit on a branch of their own (spec/<id>, knowledge/decisions) in a tree Jig makes and removes, and go as far as agent.git allows; 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 at agent.git: none they 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, at agent.git: push or above, is a base origin does not have (base-not-on-origin). Each roadmap item in jig spec list --json has an id, and what waits shows as waiting there and in jig knowledge proposed --json and sources --json, in jig writes and on a writes: line of jig status. jig writes ship carries a waiting edit further, and merges it at agent.git: merge. jig knowledge reviewed takes several ids. The text forms of accept, reject and reviewed still 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 ship refuses a merge that would leave part of the change behind. When it would merge (agent.git: merge, or autopilot.git: merge in 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. --partial says the rest is not this task’s, and what it leaves is still named. Below merge a person takes the next step, so the warning stands as it was; jig spec ship and 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.md and 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 next passes 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 list prints the same line, and jig queue next --json lists it under taken, with taken as a new reason. A note lapses after checkout.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-task skill now holds the 0–5 scale and answers “set priorities”, the Jig section of AGENTS.md says the answer goes in the queue, and jig-idea, jig-release and a phase’s run file tasks with a number. jig task new reminds on stderr (not queued: <id> — …); its stdout and --json are unchanged. See Order the work.
  • Two faults of jig upgrade --land and jig status are gone. An upgrade pull request left open for an older version no longer holds back upgrade-available in jig status --json. --land in a linked worktree on the upgrade’s branch is refused as upgrade-blocked and names the main checkout, instead of checking the base branch out there. The third entry 0.39.0 listed, that a failing glab reads as nothing to land, was wrong: a failing glab was 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 consolidated takes --revision <n> and --json as jig task resume does: a write another change has overtaken is refused with stale-revision, and the answer is the closed task, or a refusal with its code — not-closable when the close is not offered (the knowledge decision is not recorded, or the pull request is not merged), not-found for an unknown task. The two flags are refused on any other key. From an agent session, such a close was refused as stale-revision every time until 0.41.0 fixed it. See Closing a task.
  • Knowledge waiting for a person, as JSON. jig knowledge proposed --json lists each proposed document with its type, domains, path, paths, summary and, for a stub, the file it links; jig knowledge sources --json gives each linked source’s state (changed, unrecorded, missing, ok, or the stub’s own status until it is accepted) and jig knowledge sources --diff <id> --json the 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 as not-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 consolidated closes the task jig task ship filed 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 was jig 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 next before 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 with jig spec stop to ask you.
  • Your settings as JSON. jig config keys --json lists 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 set and jig config unset answer with --json too, 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 now jig 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 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:
Windows, in Git Bash:
Then .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 upgrade now looks for the Jig to copy from in order: the checkout the running jig belongs to, the source .ai/manifest records when that folder is a Jig checkout here, then the jig your PATH finds. 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 for jig 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 as jig.source: global when it is the one your PATH finds, 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 writes global. See What the upgrade does.
  • jig status follows an upgrade’s pull request. When an upgrade ended in a pull request, the plain jig status shows an upgrade 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 last jig housekeeping heard from your forge, so it is as fresh as that run.
  • jig upgrade --land brings 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 ship ships 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 .gitignore is 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 ship and the upgrade still commit only what is staged. See Choose what the agent can do.
  • jig spec list is 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 --json took 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 status and jig task list --json now read only the newest housekeeping run too; that was not measured.
  • The housekeeping log stops growing. Every jig housekeeping run that is not a dry run now trims .ai/runtime/housekeeping.log to the last ten runs, each with every record and at most 200 other lines of output, and of older runs keeps only the purge lines jig measure reads, 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 --json has two new kinds, upgrade-pull-request-waiting and upgrade-pull-request-merged, with pull_request ({branch, base, state, fetched_at}) and versions ({to}), and holds back upgrade-available while one stands; jig upgrade --land --json reports landed or nothing-to-do, and refuses as not-merged or upgrade-blocked. .ai/runtime/forge-cache lines 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-review used to answer full whenever the knowledge the review read changed, and every task’s consolidation edits GLOSSARY.md, ARCHITECTURE.md or RULES.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 is narrow and 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 means full. See Inspect the change and its review.
  • A task’s documents can be read as data. jig task artifacts <id> --json lists all twelve kinds of task document with their state (present, empty, missing or unavailable), size and time of the last change, and jig 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 list and jig status --json read 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 --json went from 4.66 s to 0.71 s and jig status --json from 0.65 s to 0.55 s; in a generated, synthetic project of 40 tasks, jig task list --all --json went from 10.23 s to 0.98 s and jig status --json from 1.21 s to 0.78 s.
  • jig task set names triage_task and triage_of as Jig’s own. It refused them before as an unknown key; it now says key 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-only task.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 start asks for the goal. A task whose ## Goal is 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 --json lists start as 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> or Linked: <repo>#spec/<spec-id> line in task.md — <repo> a path from your main checkout — makes jig context resolve list that task’s notes, or the spec’s spec.md and roadmap.md, on linked: lines. The agent records reading them like knowledge, so an edit there shows as changed since acknowledged; what is not on this machine shows as unreachable:. 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 --json and the status page count a roadmap item done when its task is closed in this clone or the last jig housekeeping saw 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 in jig spec list --json has a new done field (Reading Jig as data).
  • Open small findings go to one triage task. When jig task ship opens 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 findings says where they went, and the autopilot’s end message 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 new jig spec drop <id> checks its roadmap item and appends — moved to … (<date>): <why> or — dropped (<date>): <why> — in a checkout of the epic, or on spec/<spec-id> for a spec without one, which jig task abandon on 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 by jig task abandon without --reason, and by jig 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 resume left 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.setup stopped at worktree.setup_timeout, or still running when Jig is interrupted, now has the Windows process tree it started — php under composer, 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 after abandoned_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_ttl no longer goes to the trash and then away: it gets the new status archived, and its notes stay in .ai/workspace/tasks/<id>/ with no time limit. An active or ready task nobody touched for housekeeping.stale_after (60 days unless you changed it) is now archived too, where it used to be only flagged STALE_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 list and jig status say how many there are (archived: N), the status page has an “Archive” block, and jig task list --status archived shows them. See Archive and unarchive and Housekeeping.
  • jig task archive <id> and jig task unarchive <id>. Put an active, ready or abandoned task away by hand, and bring it back to the status it had. jig task set cannot write or leave archived. A task archived while its work was merged anyway is reported by housekeeping and the status page with jig 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 under absorbed/<from>/, <to>’s task.md gets an ## Absorbed: <from> section, <from> is archived with the reason absorbed, 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 --partial the task stays open, both sides note the overlap and the queue is untouched. When the receiving task ships, its commit and pull request carry an Absorbs: <issue> line, so your tracker’s own integration can link them; Jig never calls a tracker. A merge can always be run again, and unarchive brings 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 with action needed: a task could not be archived.
  • A program sees the archive and the links. jig task list --json has archived_at, archived_reason (abandoned, stale, manual or absorbed), archived_from, absorbed_into, absorbs, absorbs_partly and partly_in on every task, a count of archived tasks in data.archived, and the actions archive and unarchive. Schema 1 stands: archived tasks appear only when asked for with --status archived or --all (Reading Jig as data).
  • For people who release Jig itself. CI opens one issue, labelled red-main, when main goes 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 on main is not green. A push to main whose 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’s vendor/ — 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.setup runs your command in a new worktree. After the share and the carry, jig task start --worktree and every jig task bootstrap run 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 after worktree.setup_timeout (10 minutes), is never fatal, and a failure stays on the task — setup=failed (exit 1) in jig status, a setup: line in jig 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, or jig task bootstrap <id> --share packages for a task already running, gives that task the links worktree.share gives every task. See Sharing for one task.
  • The hint about an unshared folder of repositories changed. Starting a worktree names --share for a task that edits it, as an information line rather than a warning. jig status names both ways to share it, and stays quiet once the project has a worktree.setup.
  • Housekeeping deletes merged branches on the remote in one push. It used to push once per branch, plus an ls-remote when 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 resume takes --revision and --json. The resume is checked against the clone revision the way queue writes are: anything written in the clone since your read refuses it with stale-revision, and nothing changes. With --json it answers with the task as jig task list --json lists 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-checkout or stash-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: and overlap: 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 --json names a project that needs an upgrade. A new item, upgrade-available, appears on the status page and in --json when the project’s Jig is an older release than the one on your machine; it carries both versions and jig upgrade as 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, and planned for 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 code upgrade-blocked and every reason. See Upgrading a project.
  • “Upgrade Jig” to your agent. The new jig-upgrade skill updates the tool when a newer release is out (it asks jig 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 ship merged a change that raised the version even with release.merge: human, as 0.33.0 was. A change into the default branch that raises the version in scripts/lib/version.sh, VERSION, package.json, composer.json, pyproject.toml ([project] or [tool.poetry]) or Cargo.toml ([package]) is now a release: it is merged only in an unattended run with release.merge: agent, and a major one never — it is opened as a draft. See release.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 mkdir that reports success to both of two processes making the same directory, and Jig claimed its locks with mkdir. Two jig verify runs could run at once, two housekeeping runs could overlap, and the counter Jig UI and --json readers 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.share puts 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 that worktree.share does not name is pointed out by jig status, the status page and jig 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> approved now 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-autopilot skill 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, the jig-task skill 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, and jig status, your agent and Jig UI all read that one answer.
  • Priorities have one meaning. 0 broken or dangerous (data loss, a destructive operation, an install that fails), 1 a bug a user meets, 2 not a bug but it stops a user doing their own work, 3 friction, 4 an improvement or a new capability, 5 some day — so “bugs first” is set the same way by everyone. See Order the work.
  • jig queue next names the task to take: never one that waits for a dependency whose change has not landed yet, then the most urgent priority (none last), 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 the jig queue undepend to run; one Jig cannot judge yet asks you to run jig 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 --json gives 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 status shows the advice as a next: 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-task skill “what next” or “take the next one”, it runs jig queue next, names the task and starts it; on next: none it 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), undepend and remove. 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 queue write 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 code stale-revision and nothing is written; two writers that send the same revision land at most once.
  • jig queue list --json (or jig queue --json) — the whole queue in the shared envelope, in order, each item with its level, position, priority and dependencies. A write with --json answers 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 code not-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 or jig queue cancel <id> pause takes 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 pause honours it too. Continue with jig task resume <id> and a new session. jig task list --json shows a pending request as pause_request, and the task’s actions gain request-pause and cancel-pause-request, twelve in all.
  • jig task autopilot <id> stage on 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. The jig-autopilot skill 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 new jig task pause <id> --if-requested --stage <stage>, which pauses only when a request is pending.
  • The queue in jig status and jig context. jig status adds queue=<rank>/<count> and priority=<p> to a queued task’s line, with what it waits for and a pending pause request on indented lines under it; jig context with a task adds queue: 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 ## Goal in task.md, with no file to write first. With --json it answers with the filed task, the object jig task list --json lists for it; an id already taken is refused with the new code already-exists, an invalid id or goal with usage. See Filing a task.
  • Fixed: a task filed without a goal no longer shows the template’s hint as its goal. The <!-- … --> comment under ## Goal is left out, so goal is null in jig task list --json and jig task new --json, and jig task list --goals says (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 ship refused 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 ship ships a spec you closed or removed. A spec removed by jig spec close or jig spec remove used to be refused by spec ship, which read every removal as an epic’s final pull request; the removal had to be committed by hand. It now cuts close/<id> from the default branch, stages only .ai/specs/<id>/, and opens the pull request as far as agent.git allows; 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-review prints 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 paths lists 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 stable kind, from the same logic that draws the status page.
  • What a person may do next. Each task in task list --json carries actions: 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"}, or error with a stable code (usage, not-a-repository, not-initialised, failed) instead of data. schema rises 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 housekeeping keeps what it already asks the forge — pull request state and CI result — with the time it asked, and task list --json reports 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=all in your git config, a run over a worktree holding vendor/ or node_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. With no, 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.sh could run a test in the directory it was launched from and clean up there, removing that checkout’s .git and .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_model or executor.review_runtime unlike 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_model and codex.review_model, the Codex counterparts of claude.*_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_runtime and executor.review_runtime (claude or codex), with executor.implement_model and executor.review_model for 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-setup asks 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 three executor_* keys) before jig task start overrides your local choice for that task only (inherit removes the override); jig task route names 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: push or pr, or merge when the run printed not merged:, jig upgrade used to leave the checkout on jig/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-setup asks about every personal setting. It now asks about release.merge, git.delete_merged_branches and the executor.* 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.interactive and .ai/scripts/jig-notify-hook for Claude Code’s Notification hook; with the key on, jig doctor prints 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_DIR in 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 ship puts 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 its origin/ copy, git branch -d refused 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 on end the pull request link. Sending runs in the background with a ten-second limit and never holds up or fails the command; with no curl it is skipped. See Messages in Telegram.
  • jig notify setup and jig notify test. setup is 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.yaml and sends a test, so the agent never sees the token. test sends one message and prints Telegram’s answer when it fails; jig-setup asks whether you want messages and runs the test from the agent’s own session.
  • New local keys notify.telegram.token, notify.telegram.chat_id and notify.autopilot (false pauses the messages). The token is shown as ******** by jig config show, jig notify and jig status; jig config set refuses it and points at jig notify setup. A token found in the committed .ai/config.yaml is ignored, and jig status tells you to revoke it.
  • jig status reports failing messages. A notify: line names the reason and the task while the latest send failed; a later successful message clears it.
  • jig task autopilot <id> end takes 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 declares verify.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.git gives autopilot runs a Git level of their own. New key, with the same levels as agent.git (none, commit, push, pr, merge) and local only: it is read from your own .ai/config.local.yaml. Not set, it is agent.git, so nothing changes until you set it. With agent.git: pr and autopilot.git: merge the tasks you take step by step stop at a pull request for you, and a task on autopilot merges its own. jig task ship goes 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 by agent.git. jig spec ship goes by it when autopilot.unattended is true, the one case an epic’s finish merges, and release.merge: human still wins. jig upgrade and jig doctor keep agent.git; housekeeping reads both keys (next entry).
  • Jig says which level it went by. jig task ship and jig spec ship print git level <level> (<key>), jig task route and jig task autopilot start print autopilot git: <level> (<key>), and jig status prints autopilot.git: <level> (from <key>). A value Jig does not understand is refused by jig config set, jig task ship and jig spec ship, and named as invalid by jig task route, jig task autopilot start and jig status; it never falls back to another level. jig-setup asks about it, after the question about merging.
  • Housekeeping deletes a merged branch on origin under autopilot.git too. It used to do so only for a person whose agent.git was push or higher, so a run that pushed under autopilot.git (with agent.git at none or commit) left its branch on origin for good. Now agent.git or autopilot.git at push or higher is enough; every other condition for deleting on origin is unchanged.
  • Under verify.full_run: ci, a narrowed jig verify never 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), then verify: 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 says this run verified nothing here. jig verify --full and a non-empty CI environment variable run everything, as before. --explain no longer promises a full set under ci in 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 clippy and dart analyze check only what changed. Where the whole tree would be checked, the check is left to CI with skip (scope: …, full set left to CI): when the tool’s configuration changed (phpstan, ruff, rubocop, eslint, mypy, shellcheck on .shellcheckrc), when pubspec or the solution changed (dart analyze and format, dotnet format), on a workspace-wide or module-wide change (cargo fmt and clippy, go vet), and always for tsc and swift build, which cannot narrow. mypy now 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’s exclude. Without verify.full_run: ci nothing changes.
What was proven where: by tests on throwaway repositories and in CI, with the project tools (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 name git.branch_template gives 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 with git 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 upgrade and jig task ship at agent.git: merge, and the final merge of jig spec ship, now switch the main checkout back to the base branch, fast-forward it to origin, and delete the branch here and on origin (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 says kept 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 origin it deletes only for a person whose agent.git is push or higher, only with a merged pull request, only while the branch is still at that pull request’s head, with housekeeping.fetch not false, and (on GitHub) the pull request has to be among the last 200 it lists. jig housekeeping --dry-run prints what it would delete as would delete branch <name>. Its fetch now passes --no-prune, whatever your fetch.prune says: the copy of a branch on origin is what git branch -d compares a squash-merged branch against, so it is dropped only after its local branch is gone and origin no longer has it.
  • git.delete_merged_branches turns it off. New key, true by default, a local key, so your own .ai/config.local.yaml overrides the project file: jig config set git.delete_merged_branches false --local keeps 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-update to a project back at work, in order: the clean start, what each agent.git level leaves to you, the manual steps, skipped releases, branches in progress, restarting your agent’s sessions, the jig doctor and jig status checks, and what colleagues do. It also lists the refusals an upgrade can end in and what to do.
What was proven where: by tests on throwaway repositories and in CI, with the hosting site’s 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 doctor at 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 upgrade at 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 a warn line. 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 status at a terminal reads by section. A heading that ends in the verdict, then Needs you (only when something does, each item with its hint:, fix: or see: 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, and NO_COLOR or TERM=dumb removes 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 doctor and the counts the status page caches (status-counts) are unchanged.
  • Tasks in jig status are 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.sh and install.ps1 print a level word (ok, warn, fail, and ask for a question) padded to six columns, with the PATH advice and the other notices before the closing ok jig installed: ...; an error is a fail block. The PowerShell installer colours through the console (ok green, warn yellow, fail red, ask cyan), never through escape codes, and runs jig doctor in its grouped form without colour. jig-setup asks and reports in the same form.
  • Output switches. JIG_TERMINAL=1 forces the terminal form and JIG_TERMINAL=0 the plain one; NO_COLOR (any non-empty value) and TERM=dumb remove colour and keep the grouping. A reader that needs the old text under a terminal sets JIG_TERMINAL=0.
  • An upgrade refuses only where a started task holds this checkout’s branch. jig upgrade used to refuse because another session had run jig status hours earlier, or jig task show on 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 start and jig upgrade now answer “who occupies this checkout” with one rule. jig verify running 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.
What was proven where: by tests on throwaway repositories and in CI. The terminal form of 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 true and jig task ship read 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 match design.md), spec.md and alternatives.md for T4, a review receipt for the review of T2 and up and for the architecture review of T3, and status 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, and jig 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> resume now needs --answer <the human's answer>, which is journaled and printed in the report under “Resumed on an answer”; in an unattended run resume is refused, and end there requires knowledge_consolidated true, so a run cannot reset its repair limit by ending and starting again. jig task gate <id> approved without --by agent is 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/tasks or a task’s own entry used to slip past the check of jig task artifact write and append (a planted tasks link wrote plan.md outside the repository with exit 0). Every command that writes into a task workspace, jig task new, jig spec link and remove and 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 links jig task start --worktree makes and a coordinator’s own .ai/workspace link 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 --finish and --reopen run on the epic or on a branch cut from it, and the final jig spec ship cuts finish/<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 protects epic/* like the main branch needs no bypass; the epic-pr check accepts a finish/<id> head. See Agent ships.
  • New personal setting release.merge. agent (the default) keeps today’s behaviour: an unattended run at agent.git: merge merges an epic’s final pull request once CI passed. human opens it and leaves the merge to you. Local only, set with jig 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_model and claude.review_model (set by hand or through a new jig-setup question), 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 a delegate: 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 the delegate: lines; no run of a helper on another model is kept as a test. See Autopilot.
  • jig-verify no longer leaves a log in your working tree. The skill used to tell the agent to redirect jig verify into verify.log in 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> --worktree on a started task (with git.branch_per_task on) 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 names jig 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 (a packages/ folder, Composer path repositories): worktree.share: [packages] gives each task worktree a real packages/ 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 by git 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 bare git worktree remove, and finds both in the owner’s checkout; the same steps with carry, 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 by jig task bootstrap <id>; a path declared as both carry and share is 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, and jig task route. route.depth: lean (set with jig config set route.depth lean --local; the default is full) lets you run less of a class’s route: a T1 analysis is a few lines in task.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.yaml is ignored and reported, as for agent.git. For one task: jig task new <id> --lean, or jig 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 status marks a lean task depth=lean, the status page badges it, and jig task autopilot start and report print the depth. See Concepts.
  • jig-release: an agent can plan a release. A new skill (placed by jig 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), and jig task list --goals prints 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 context resolves 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, because jig context returns those. And every receipt check now resolves that knowledge, which jig status, the ready status and jig task ship all run, and the cost grows with the known issue that jig context is slow on a large project. jig status therefore no longer resolves it: it compares the change, the design and the findings, and for a receipt that still matches says not checked rather than current; jig task receipt --check, the ready status and jig task ship still check everything. Measured on five tasks that each had a receipt and a worktree, jig status took 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-message and pr-body (the files are commit-message.md and pr-body.md), so jig-consolidate, jig-map and a phase run no longer write them with a shell redirect, which jig-task forbids. jig-review and jig-architecture-review keep 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, through ddev exec --raw), Lando (.lando.yml) and a devcontainer (.devcontainer/devcontainer.json, through the devcontainer CLI when it is installed, otherwise the labelled container) now have detectors; Lando and a devcontainer without its CLI are reached with docker 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 service php, 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’s bin folder first on PATH. Devilbox’s detection was tried against a real running stack (the container was found and php -v ran through the prefix); a full jig verify there, 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.exec and run.path override it (Configuration).
  • New personal setting run.path. A folder put first on PATH for 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, dart and swift profiles joined php, laravel, node and generic: inside an environment their checks go through its prefix instead of being skipped. Under an environment, Python does not use the $VIRTUAL_ENV or poetry of this machine; its tools come from a .venv/ or venv/ that runs there, otherwise from the environment’s own PATH. This was tested with a stand-in for docker whose tools exist only inside the “container”, not in real containers.
  • jig doctor and jig verify --explain warn 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 with require.php in composer.json, engines.node in package.json and .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 doctor also lists the runtimes that match; jig verify --explain prints 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 stop jig verify.
  • jig task start refuses 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 with jig task new or ran jig status no longer blocks the next start. The refusal and jig upgrade’s matching stop no longer advise deleting the other session’s record: it lapses by itself after checkout.busy_ttl.
  • Paths with a backslash no longer confuse container detection. The container reader now passes project paths to awk in 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 verify runs 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 setting run.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_HOST naming 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. The php, laravel, node and generic profiles run through the environment; when checks run in one, a profile not yet adapted is skipped with the reason, never run on the host. With CI set and run.exec left at auto, nothing is detected and nothing is refused. The jig-setup skill now asks where your tests run, as its eighth question (Configuration, Troubleshooting).
  • jig task start refuses 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 its jig-* folders in your temporary directory (more than 4,600 had piled up at once).
  • A shared shell library change narrows what jig verify runs. With the shell profile, 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, a source, a new or removed function or file, a function nobody calls, a caller with no test — it still means the whole suite. With verify.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: domain knowledge reaches the files it names. A document with load: domain was required only when its domain was entered; its paths were ignored. jig context now 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, accept and reject now refresh the jig status --html page 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’s jig 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 upgrade now runs as its own change, on its own branch. It checks first that it may start — no uncommitted changes, no core.autocrlf without Jig’s files pinned to LF, no other session or jig verify busy in this checkout — then works on jig/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 as jig 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 doctor tells you when a newer Jig has shipped. Its latest release line 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 status shows a newer Jig release too, without running jig doctor for it. Housekeeping now checks the same thing once a day in the background and keeps the answer; jig status (plain text and the --html/--open page) reads it offline and, the moment a newer release is out, prints jig 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 subst drive, a volume kept for one project, or a \\server\share that 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 default core.autocrlf=true no longer reads its own manifest as empty (Upgrading).
  • jig housekeeping no longer hangs waiting for a credential prompt nobody can answer. Every network git call it and jig self-update make 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 consolidated now checks with the forge first and refuses unless the pull request has actually merged, so a task does not disappear from jig status while it still needs a merge.
  • jig verify tells 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 context and jig knowledge check are markedly cheaper on a real repository. One shared tree walk replaces a filesystem find per 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 repeated resolve/guard calls 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 new and the new jig spec resume <id> switch to the spec’s own branch first, the same branch jig spec ship already used; jig task start’s dirty-tree refusal now names jig spec ship when 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 status runs jig status again 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 --reason and similar free-text values could have a backslash sequence reinterpreted on the way into the task’s state file — a Windows path like C:\temp no 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 -Yes does 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 subst drive, a volume kept for one project, \\server\share. Jig is installed, only the project step stops; run jig init in that folder yourself (Known issues).
  • An interrupted jig upgrade is finished by running it again. A file that already holds the new version is recognised as placed, reported already-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 upgrade says 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 run jig upgrade again — instead of leaving it for jig doctor to 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-update and jig 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 verify does 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 set instead of scope: not narrowable, ran full set.

0.16.0 — 2026-09-25

Green now means green.
Do this after upgrading: install the tools your project’s checks need. jig verify used to answer ok when a profile for your stack was active and every one of its checks had been skipped for a missing tool. It now refuses — exit 3, nothing was checked, so this is not a pass — and jig task ship will not ship on it. jig verify --list shows which profiles are installed; install what they need (npm install, composer install, a virtual environment, shellcheck …). If you wrote a profile of your own that deliberately checks nothing, add verifies: nothing to its profile.yaml: absence means the profile asserts something, so it refuses rather than quietly becoming unverifiable (Troubleshooting).And if jig upgrade reports keep-unmarked AGENTS.md: run the jig-init skill. This release keeps the Jig section of your AGENTS.md current through an upgrade — but only for a project whose manifest carries Jig’s claim to that region, and jig init is the only thing that writes that claim, on markers you agreed to. Adding the markers by hand does not do it: without the claim every outcome stays a keep-. If your section has also drifted from Jig’s own text, markers alone are still not enough — no claim is recorded and upgrade goes on reporting keep-modified. Reconcile the text with .ai/templates/AGENTS.md first, then mark it. That nothing does this for you is deliberate: the first time Jig claims a region of a file your project already had is a moment that belongs to you.All three of this release’s manual steps — these two and verifies: nothing — are set out with the commands that prove they took on Upgrading.
  • 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 ok either: jig verify says nothing here checks this project and exits 0, and jig task ship says it again as the change leaves your machine.
  • jig task ship refuses 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 verify waits for one already running in the same clone and says how long it waited (verify.busy_ttl: 0 turns 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 --explain says what a run will expand to, before it runs. One line per check — full, filtered, skip or conditional — 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.carry copies 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 status gains a working here: line for each live record, and the commands a session orients itself with warn it, on stderr, when HEAD moved underneath it.
  • jig upgrade keeps your instructions current. For a project that has made the claim above, it refreshes the Jig section of your AGENTS.md instead 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 status also reports the config keys your .ai/config.yaml no longer mentions — capabilities a new version brought that nobody offered you.
  • Jig acts on the repository you ran it in. GIT_DIR, GIT_WORK_TREE and 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.md documents the keys of profile.yaml for anyone writing their own.

0.15.1 — 2026-09-23

  • Fix: jig upgrade in copy mode replaced .ai/scripts/jig by 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.git decides 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 with jig task ship and jig spec ship (Handing over the git work).
  • Autopilot: the jig-autopilot skill runs a task’s whole route without waiting between stages and stops only where a human is needed. autopilot.unattended is 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-setup skill asks how far your agent may go, one question at a time, and writes the answers to your personal settings with jig config set --local.
  • jig status --html and jig status --open write a status page that leads with what needs you — stopped runs, gates, findings, open pull requests.
  • Fix: jig upgrade no longer rewrites .ai/manifest when 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.md or CLAUDE.md does not carry the Jig section — the reason an agent silently ignores the workflow. jig init, jig status and jig doctor all report it.
  • jig init records the repository’s actual base branch instead of assuming main.
  • 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. -NoSessionHook skips the hook.
  • jig upgrade removes an orphaned file only inside .ai/ or an adapter’s skills folder; anything else is kept and reported.
  • Smaller fixes: jig help documents spec close and spec epic; jig task start explains itself in a repository without commits; jig knowledge suggests 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-init can set up a project that has no code yet — it carries the architecture, stack and invariants decided in a jig-idea specification into the project’s knowledge and turns on the matching profiles.
  • jig-idea asks 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 verify narrows 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 init turns on every stack it detects, not generic alone.

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 their ADR-NNNN citations.

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 in jig context, instead of only sitting there proposed.
  • Drift is visible. A stub records the text that was approved; jig status counts the sources that changed since, jig knowledge sources --diff <id> shows what changed, and jig 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-convention reads 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> --finish now removes the finished specification instead of marking its roadmap line, and --reopen restores 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.yaml holds the keys that are yours rather than the team’s — housekeeping cadence and lifetimes, the worktree root. jig status and jig doctor warn 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 reaches main as one pull request and one release.
  • Every task records the branch it was cut from, so work landed somewhere else is flagged wrong-base instead of being read as merged.
  • verify.full_run: ci lets a plain jig verify check 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.cmd for 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 init merges the needed .gitattributes rules.

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> --proposed records 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> and jig 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 new and jig spec list, and the jig-idea skill 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 init sets 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 verify with stack profiles, jig housekeeping for what tasks leave behind, jig measure, and jig 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.