First: what takes work away from you
Nothing known today. When something is found, it goes here, ahead of everything below.Then: what tells you something untrue
A green verify must belong to the files it checked. A review already records what it read, and says so when the code moves on underneath it. A verify result does not: once the checks pass, the task reads as verified even if files changed afterwards, and a change can be shipped under a result that was earned by a different tree. The result gets pinned to its inputs, the way the review is, and a moved tree asks for a new run. A write from a page must only ever publish what it was meant to. 0.40.0 made a roadmap edit and a knowledge decision possible without moving your checkout, and a rule stops a write publishing commits origin never had. The faults found since, around pull requests closed or squashed under it and branches deleted on origin, are fixed in 0.41.0. Next, a smaller step: a spec created after a write already took its branch name should get another name.jig spec new now refuses it when that branch
is in your clone, and loses nothing; a write branch that exists only on origin is not caught yet.
From 0.45.0 jig refresh closes a write whose pull request merged — squashed included — or closed.
Then: what costs you time
A second review round must not open a new front. A repeat review already reads only what changed since the review (0.30.0). What is left: a blocker that appears only in the second round goes to you instead of starting a third. Each extra round is where the time goes, and this bounds them. An uncertain finding gets a second opinion before anyone fixes it. A review finding the reviewer is not sure of is handed to a fresh agent that has not seen the reasoning behind it, and is kept only if that agent confirms it. A wrong finding then costs one check instead of a round of fixes. A profile changes one check of another in a few lines. From 0.41.0 a profile can take over a check of another by its name (covers:), so a Laravel project runs its test suite once. Next, every
stock profile names its checks, and a profile builds on another and changes only what differs,
instead of copying it; until then a profile under .ai/profiles/ that no active profile reaches
stays silent.
After that: new capabilities
Planning that lives in Jig. Jig can be read by a program (0.29.0), planned with (0.31.0) and asked what to take next (0.32.0): a queue holds the priority, order and dependencies of tasks and epics, a running task can be asked to pause, andjig queue next advises the next task from them.
From 0.45.0 a task nobody started is paused directly, and your agent offers the task
jig queue next names. What is left: a way for jig init to tell an installed Jig UI about a new
project.
Reviewing somebody else’s pull request. Give Jig the address of a colleague’s pull or merge
request on GitHub or GitLab, read the review exactly as it will be posted, say yes, and it lands as
one comment-only review; after the author’s fixes, a follow-up answers its own earlier comments.
All of it is in 0.42.0; from 0.44.0 each finding carries its severity and a number, and the skill
is installed for you, so it works in any clone. What is left is checking GitLab’s posting, the
follow-up and the severity layout on a live merge or pull request.
Git flows. A project picks how its tasks travel: direct, straight to the main branch, or
staging, where a task lands on a staging branch through a reviewed pull request, waits there
parked while QA tests it, and reaches the main branch on “prepare for prod”, said by a person or run
by CI. All of it is in 0.45.0 (Test on staging first). What is left is running
it on a real project, GitLab included (task staging-flow-field-check); deciding whether an epic’s
work passes through the staging branch, once a real epic meets one (task epic-in-staging-flow); and
telling a squash merge, into the staging branch or out of it, from work that is not there
(Known issues).
Project hooks. A way for a project to bind its own rules and its own checks to stages of the
route, so that what a project insists on is asked at the stage it belongs to rather than remembered.
A bug fix starts from the failure. For a task that fixes a defect, the route asks for the
failure first — reproduced by a test or a written check — then the fix, then the same check again.
Defects leave a record, and records become rules. A fixed defect leaves a short structured note:
the cause, the kind of mistake, the files. A skill reads many of them and proposes project rules
for what keeps recurring; a person accepts or rejects each one, as with any proposed knowledge. This
needs a decision recorded first, because it is a new kind of record.
Knowledge documents that name each other. An ADR that replaces another, a document that affects
another — written as typed links and checked mechanically, so that a replaced decision cannot stay
quietly in force.
Beyond that, ideas with no start date: a link from each requirement in a specification to the check
that proves it; accepting a known failure with a reason and an end date rather than switching the
check off; a separate security pass for the riskiest tasks; noticing an unattended run that has
gone silent; knowledge shared between several repositories — a task can already read a
neighbouring repository’s task or spec (0.38.0), but not its .ai/knowledge/; and knowledge that
lives in a section of an existing file rather than a whole one.
Beside Jig: Jig UI
Jig UI is a separate, optional project, in the making: a local page with a board across all your Jig projects, where tasks and epics are ordered and prioritised and new tasks are filed. It reads and changes your projects only through Jig’s own commands and contracts — the JSON form described in Reading Jig as data, and the planning described above — so Jig works exactly as it does without it. What its next phase needs from Jig — the queue, pause requests and filing a task from a program — is in 0.31.0, so that phase can start on it; resuming a paused task from a program is in 0.35.0; the archive and the links between merged tasks are injig task list --json from 0.37.0; whether a roadmap item counts as done, merged work included, is
in jig spec list --json from 0.38.0; jig task list --json no longer starts processes for every
field of every task from 0.38.1, so jig task list --all --json on a project with dozens of tasks takes about a second
rather than about ten (measured on a synthetic project of 40 tasks; see the changelog);
an upgrade’s pull request is in jig status --json, and jig upgrade --land --json brings it in once
merged, from 0.39.0, so a program no longer has to remember it; closing a task with the revision it
read, the settings as JSON, the knowledge waiting for a person, its decisions and roadmap writes that
leave your checkout alone are in 0.40.0; from 0.41.0 a finished task leaves the queue, so the board
shows only the work left, and an upgrade from unreleased Jig is refused as unreleased-source; from
0.43.0 an upgrade whose pull request is still open is refused as not-merged, not failed, and a
refused close says why GitHub or GitLab could not be asked; from 0.45.0 jig status --json says how
far a clone is behind origin and jig refresh brings it up without moving the checkout, a task
nobody started is paused directly, and, on the staging flow,
each task in jig task list --json says whether it is on the staging branch and why it is parked, and
jig task promote is the command a card moved from Staging to Ready can run, with no agent unless
the main branch conflicts. Its plans
live in its own repository, and its documentation at jig-ui.fapost.in.