Skip to content
v6.3.0MIT

Skill that turns your coding agent into the director of a feature branch: an issue loop (kept out of git by default, committed when you ask) where everything seen becomes an issue, a worker per issue works in its own worktree, evidence and a fresh review decide what closes, and a branch loop leaves no trace on main.

Changelog

All notable changes to this project will be documented in this file.

The format is based on Keep a Changelog. Up to 0.1.0 Jarl followed Semantic Versioning on its own number. From 6.1.0 it follows the Yggdrasil family's one-number policy instead: the core of the family (Yggdrasil, Grain and Jarl) ships together under one number, so a minor release can include changes that ask something of you, and its section lists them under Before you upgrade. A release in which Jarl does not change says "No changes in Jarl."

Unreleased

  • round counts its findings with --finding-count <n>; --findings keeps working, on the command line and in the tool, and the call says to use --finding-count.

  • set --worktree says whether it checked the path: a path that is not on this machine is not checked, and the note says so instead of saying it was checked.

  • decide --by owner with his words no longer prints a note about a missing question.

  • decide says on stderr when a ruling with no --applies-to reads as an instruction, so a rule meant for agents is not left as a record that reaches nobody, and names the call that makes it a rule. A rule is handed to an agent as its instruction alone: the Made under: line and the owner's words stay in the record.

  • A lease is no longer reported as idle while its worker changes files in its worktree: the newest change to a file there counts as activity alongside commits, rows and log lines.

  • decide --supersedes takes several rulings in one call (a comma list, or the flag repeated) and marks them all or none. A supersession written by mistake is taken back with retract <slug> supersession "<why>" --by <who>: the ruling is in force again and the reason is kept in the record and the log. A Jarl 6.3.0 that reads such a record shows that ruling as superseded still, and reads every other field of it as before.

  • decisions --as <role> lists the rulings that are rules reaching that role (with --live, only those still in force), so a new rule can be checked before any brief is raised.

  • Issues leased together on one branch are one lease for brief and next even when their Repo fields name the same repository once by its name and once by a path.

  • A rule scoped to a repository (decide --applies-to "repo <name-or-path>") now reaches the issues that name that repository whether the rule and the issue write it as a name or as a path, and decide refuses a repository the loop does not know instead of saving a rule that reaches nobody.

  • On Windows, a brief names a worktree with backslashes, as the platform does.

  • On Windows, the form a refused call prints carries an empty --root= as given, instead of naming the loop root by its placeholder.

  • On Windows, the git commands Jarl prints for a kept worktree and for a merge that moved past its review are quoted for PowerShell and cmd, and a record file that came back with CRLF keeps its line endings when Jarl writes to it.

  • Changing an issue's title, description or acceptance no longer fails when the old text ends with the words "owner's word" and a full stop.

6.3.0 - 2026-11-09

Jarl 6.3.0 lets coordinators each run their own part of a loop, makes every write name who made it, and raises each worker, examiner and merger with one complete brief the tool prints. It reads only one record format, so a loop kept by 6.2.0 is converted once before it is used again.

Before you upgrade

  • Jarl 6.3.0 reads one record format, the one whose goal.md holds the line Format: 4. A loop kept by 6.2.0 or an older Jarl is refused on every command, with a message that names references/converting-from-6-2.md in the skill. There is no conversion command: once nobody else is writing the loop, an agent converts it by following that file. Nothing the loop held is lost, but the writer of every old log line becomes unrecorded, and rows that named no line stay as history and count for no line, so a line marked test, check or compare needs its proof recorded again, while a line with no mark reads as read and an approve already given still clears it.
  • Jarl 6.2.0 does not refuse a converted loop, and writing to one with it damages the loop: it writes the old format, and 6.3.0 then refuses the loop as invalid. Every machine and plugin that touches a loop has to move to 6.3.0 together.
  • Calling Jarl changes. Every command that writes needs --by <who>, and nothing fills a name in for you. Starting a task needs --worker and --model, and a verdict from an agent needs --model. Every acceptance line starts with how it is proved ([test], [check], [compare], [read] or [owner]), a line without one is refused, and a proof row names the line it proves with --line.
  • These commands are gone, and using one prints the call that does the same: body, tag, prio, files, repo, source and after (use field), tips and queue (use resume), and check (use scope).
  • A tool built on Jarl's record library takes jarl-record/4, the library's one contract, and reads only that format. If you copy the library into your own tool, copy the scripts/lib/ folder too: it sits next to record.mjs and jarl-lib.mjs, and the library does not work without it.

Added

  • An issue that names several repositories is done only when its branch has landed in each repository where it has work; the merge queue keeps the ones that have not. The page of numbers shows the lines by method and the count per stage.

  • Closing a loop that removes its record is refused while a question is unanswered, and names them; --force still closes it, and a permanent loop keeps its questions.

  • The merger's brief says to skip the changelog step where a repository keeps no changelog, the model guidance says a lone agent holds the merger's role, and a coordinator is told that what is not in its slice is not its business, even when the record shows it.

  • verify prints the git commands that take one side of a record file a merge left conflicted, and names an issue two copies of a loop both leased, with the form that keeps one. An examiner on too weak a model is told how to say so instead of giving a verdict, a coordinator is told to start from its slice's brief, brief takes a range of issues, and an issue landed through a slice's own branch keeps its gate.

  • The brief a coordinator is raised with lists the open questions of its slice, says how far each issue in flight has come, and marks which issues are promises or waits, so a coordinator taking over a slice sees what the one before it left open.

  • A worker, a reviewer or a merger is raised with one complete brief the tool prints, every command filled in, and reads nothing else for its role. What each agent is told to do next now shows a takeover that is due, sends a stuck worker's question to whoever directs its work, and lists the work nearest to landing first.

  • The owner can close chosen tasks without a review, by a decision of his that names them and keeps his own words. Nobody else can. The decision counts until the task is sent back, reopened or its code changes, and the status counts such tasks apart from reviewed ones.

  • A note written on a task can be taken back, as an evidence row can, with who took it back and why. The issue view that a worker reads leaves a retracted note out, and the full view shows it struck through. A note that records the owner's own words can be taken back too.

  • The owner can take back a sign-off he gave by mistake on one step he checks himself, and say why. The task then waits for his sign-off on that step again, and nothing else is undone.

  • Every part of an issue's description can now be corrected, including its tier, its kind and who found it, and the record keeps who changed it and what it said before. What happened to an issue, such as its test results, reviews and merges, is never edited, only taken back or replaced.

  • You can ask Jarl what is waiting on one person: the owner's open questions, or the next step of every task for whoever runs the loop, each with the command that takes it. The status and the resume of a loop can end with that list. Work on code that waits for a review shows as one line, cut into groups one reviewer may take: the tasks built together on one branch, named by their branch, and every other task alone. The line comes with the question that asks the owner to start a fresh session if no reviewer can be raised; once that question is asked, the work shows on the owner's list.

  • A ruling made by the jarl or a coordinator can now name the ruling it rests on, such as the owner's mandate. The name is shown with the ruling in the list of rulings and in the resume, and a name that is not a ruling in force is refused.

  • When the text of an open issue mentions another unfinished issue by number and nothing orders the two, filing or editing that text and checking the record now print a note naming both, so you can say which comes first. The note changes nothing and never stops anything.

  • To have the note name another issue, write its number after the word issue, or with a hash sign in front of it, and put a space after each comma in a list of numbers. A list written with no space after its commas, or a bracketed list of two-digit numbers such as (12, 13), names no issue.

  • A task can be handed to a new worker on purpose, with the reason it changed hands, and the record keeps that reason. The old worker's branch and folder are then no longer reported as a problem.

  • A step you want to check yourself can be written into a task as a line only you can tick, naming what you are to look at and what to check. Jarl will not close the task until you tick it, and shows it in your list of things to do once there is something to look at.

  • A loop can now say after how many failed rounds a kind of task is handed to a fresh worker, with a line such as Takeover (docs): 2 in its goal. A line Takeover: 4 sets it for every other kind, and a loop that says nothing keeps three. A changed number counts from the next failed round, and the rounds are counted from the last handover.

  • Two copies of one loop, such as two clones or two branches, no longer mix up two tasks that got the same number. Each task gets its own key when it is filed, a new task skips the numbers any branch of your clone already uses, and after a merge one command gives one of the two tasks a new number with all its history kept. Two people taking the same task in two copies show up on the jarl's list, and the record check stops at a task file left half-merged by git.

  • The word Key is now reserved for that key: a new profile that declares a field named Key is refused when you open a loop with it or check it. A loop you already run with such a field keeps it as it is, and its tasks get no key of Jarl's.

  • A coordinator named in the goal can run its own part of the backlog: tag an issue slice:<name> to put it in that coordinator's part. An issue belongs to one part at most, and the status shows who runs which part.

  • A coordinator can look at its own part of the backlog alone: what to start next, the status and the resume each take the part's name. A task waiting in one part never holds back a task in another; only work already started does.

  • Asking Jarl what is waiting on a coordinator now lists the tasks of its part: the ones ready to start, the ones being worked on, the work waiting for a reviewer and the work sent back. Tasks in no part stay with whoever runs the loop.

  • A coordinator can send a question up to whoever runs the loop, naming its part of the backlog or the task, instead of going to the owner. The question shows on that person's list and in the coordinator's view, and the task it names waits for the answer.

  • The goal can name the one coordinator, or the person who runs the loop, who starts the merges, with a line such as Merger: odin. Every approved task waiting to be merged, in every part of the backlog, is then on that one list, so only one merge runs at a time.

  • The guide for running a loop now describes coordinators, each over its own part of the backlog, in place of a single assistant: when a coordinator should turn to whoever runs the loop (four cases), that each one waits on the helpers it started, and that one named person starts the merges.

  • A loop can now record a promise someone made, or something it waits for from a person outside the loop, and each stays on that person's list, a wait with when to check, until it is closed. Jarl never gives either to a worker.

  • Jarl's command line prints its version with --version. The number matches the one the Jarl tools in your session report. When your shell exports CLAUDE_PLUGIN_ROOT, and the plugin there has another version than the copy you run, resume says so in one line; without that variable it says nothing.

  • A ruling can say whom it is for and until when: the whole loop, a role such as reviewers or workers, one coordinator's part of the backlog, a tag, a kind of task, a set of files, a repository or a moment of the work, and it can end on a date or when a task closes. Taking it back is a ruling that replaces it. The resume and the list of what is waiting on someone show that person the rules meant for them, in full, and the resume no longer lists every ruling.

  • Jarl gives coordinators, workers and reviewers its own working rules for their role, such as re-checking every acceptance line on each review round.

  • Anyone in the loop can propose a rule, for whoever runs the loop to accept, or for the owner when the rule is his. When the loop closes, each of its rules is offered to the owner: keep it for the next loop, write it into the repository's instructions for agents, make it a rule of the code, or drop it.

  • report --metrics prints only the loop's metrics, so the summary stays short even for a loop with hundreds of issues. report now prints the metrics before its lists of issues.

  • Jarl now flags a task that seems stuck after 30 minutes instead of six hours: work with no commit, proof or note for that long, or proof waiting that long for a review, shows as idle in the status, the resume and its coordinator's list (an approved task waiting for its merge is not idle, the merger's list shows it), and a task waiting on a shared resource shows how long ago the task holding it last moved. A line such as Liveness: 60 in the goal changes the minutes.

  • The loop's report now counts, for each person who runs part of the loop, how many tasks they reopened after closing them and how many pieces of proof or approvals they took back, taken from the name each of those steps was recorded with.

  • Jarl can write the brief you hand to a worker, a reviewer or a coordinator, so you no longer write it by hand: the task, the rules meant for that person, what earlier reviews found, the proof so far and the command that records the result. A tool built on Jarl can get the same brief as data.

  • A task can be split into smaller tasks, and those split again, so the backlog becomes a tree. Each checkable line of the big task goes to one of the smaller ones or stays with it, and Jarl refuses a split that would lose a line. The big task waits until its smaller ones are done, then its coordinator checks the whole before it can be closed. The smaller tasks keep the order, the part of the backlog and the rules of the big one.

  • A reviewer can hand in a problem it found outside the task with its verdict, and Jarl files it as a new task found by that reviewer. Such a problem never sends the work back; a verdict that would send it back for that alone is refused.

  • Importing a findings file again, the same way as before, reports each finding whose text differs from the task the import filed for it, with both texts, and leaves the task as it was; a finding with neither a claim nor a truth is not compared. Outside tickets can be followed this way: file them under one parent task and import again whenever the tickets change.

  • One verdict given on several tasks at once is now recorded as one shared review, and the report lists each shared review with how many tasks it covered and how many failed rounds came after it.

  • A review can be recorded as given by a bot, such as one that reviews pull requests. Each loop says in its profile whose approvals close a task: by default a separate agent's or the owner's, never a bot's, and a loop may add a bot it names or ask for several approvals together. The status and the report count bot and relayed reviews apart from the others.

  • Importing research findings can put every task it files under one parent task with --parent <id>, so a set of outside requirements is filed as a tree in one call instead of one command per task.

  • Opening a loop whose goal has no line naming the models per tier now says so, with the command that adds one, as it already does for a missing check. The first lease that raises an agent with a model in such a loop says the same once in its own answer, naming the strongest tier for the jarl and the standard tier for the coordinators; nothing else offers it again.

  • scope and the recording of a merge now point out each added line that starts a conflict marker and each added file over 64 MiB, the largest file Jarl accepts as an attachment, with its file. They only say so and never stop a merge.

  • A loop's profile can name the strongest model the loop may use and the models it may not use, to keep its cost down. Jarl's advice then stays within that: the model it suggests for a task, the step up after failed rounds, and, when a review would need a model above the limit, the lighter worker that makes the review possible.

  • A review can name the screenshot, render or file it judged, so each look at a picture is its own verdict on record. It takes a plain path inside the repository and refuses an address or a place on one computer. The task shows it with the verdict and the report counts such reviews.

  • A session can name the loop it works on once, with use, instead of on every call; use alone lists the loops kept in a repository. On the command line use prints the setting to export, and the command line now reads JARL_ROOT. When a repository has no loop at its top but has some further down, a call that names none is refused with their list instead of guessing.

  • The record check and the resume now list each ruling in force that names tasks it settles which are not yet done or dropped, so a ruling nobody carried out no longer goes unnoticed. It is only a note and never makes the check fail.

  • A loop can keep a series of tasks apart by number, such as films from 1000, with a line Range (film): 1000-1999 in its goal, and file a task in it with new --range film. Other tasks keep counting on their own, and a file numbered by hand moves no other series.

  • A loop that is already running can get a new section or a new field on its tasks with extend section "<name>" or extend field "<name>", checked by the same rules as a new loop's profile and noted in the log, instead of editing the profile file by hand. Tasks already filed stay as they are until you fill the new part in.

  • A task that only writes its own files, such as one document, can be tagged in-place: its worker writes them where they are checked out, with no branch and no merge, and the person who commits there commits them. Jarl closes such a task only once a recorded proof names that commit.

Changed

  • A raised worker, examiner or merger reads only the brief the tool prints. The skill itself is short and read by whoever directs the loop; the rarely needed material moved to the command reference, read on demand. --help now prints one line per command, and <command> --help one command's usage; jarl_help still prints all of it.
  • A task cannot be started until it has at least one acceptance line.
  • A task closes when each line has what its method asks. A test needs a proof row from the worker and one from someone else. A read line needs an approve and no row.
  • If the text of the acceptance line a proof row names changes, the row stops counting for it.
  • A requested change now holds until the work goes back or a new commit lands. An approve from someone else no longer clears it.
  • Jarl keeps the full old text of the lines when they change, and can show them as they were when the work started.
  • Which reviews can close a task is set by the loop. By default any reviewer who is not the task's worker counts, whatever model it runs on, and the message after a review says plainly whether the task can now be closed. A loop can ask instead for a reviewer on another model than the worker's, or on one at least as strong, and then a review that does not meet it, or that does not say which model gave it, cannot close the task. The line after such a review gives the review call that names a model, instead of pointing to closing the task, and the merge queue lists such a task as waiting, with what is missing, until a review that meets the rule is given.
  • A task worked on its own branch can be closed only after its merge is recorded. Before, Jarl closed it without one and then flagged it as closed wrongly. A task without a branch closes as before.
  • A new loop cannot use the words Person and Check when for fields of its own, or promise and wait for kinds of its own, because Jarl now uses them itself. A loop that already uses them keeps working as before. Jarl's own promises and waits are off there, as they are in any loop whose profile lists its own kinds.
  • A task another worker already holds, or one that would touch a file or resource another worker holds, is now refused when you start it, naming who holds it, instead of quietly replacing that worker. Adding such a file or resource to a task that is already started is refused the same way. To give a held task to someone else, say it is a handover and why.
  • When a new issue is filed without a kind or a priority, Jarl says which one it took and names the option that sets it, as it already does for the tier.
  • When more than one part of the backlog has work in play, a task can only be started once it says which files or shared resources it touches, so work in two parts cannot collide unseen. The tasks that belong to no coordinator count as one part, so even a single coordinator beside such tasks is enough to be refused. The refusal names the command that adds them.
  • Every change to a task's description now goes through one command, field: give a part a value to replace it, or add to it, take items off it or clear it with --add, --remove or --clear, and a section such as the acceptance can be added to as well. A repository's base branch is changed with base, and set takes statuses only.
  • The counts of status and models are grouped with --group (status --group repo). A review or a piece of proof is taken back only with retract. Each of the old spellings is refused with the form of the call to use instead.
  • Free text is given the same way to every command: as the last argument on the command line, and as the field text in the tools, whether it is a note, a reason, a review's findings, a question, an answer or a ruling. The tool field that names what retract takes back is entry. A tool given a field by a name it no longer has, such as why or findings, or by on status, says which field to use.
  • An answer and a ruling given on the command line or through the tools now always say who gave them, and nothing is taken to be the owner's or the coordinator's when no name is given. A tool built on the record library records an answer as the owner's and a ruling as the coordinator's when it names nobody.
  • The merge queue and the branch tips are read in resume, which already showed both. resume --repo narrows both to one repository, --base sets the base the merge queue is measured against, and --gh asks gh for the CI of the tips (resume --ci is refused with the form of the --gh call, as --ci is the CI state merged records; a tool built on the record library still asks with ci).
  • The help lists each view that only reads with its one purpose on one line, and the guide's table of daily commands shows how to change a task and that an answer and a ruling name who gave them.
  • When Jarl refuses a call, it says what is wrong, naming the word of your call that is, and the last line of the message is the form of the command that does what you meant, with a <placeholder> for each value only you know and the values allowed named in the message: fill the values and run it. Jarl never writes a value in for you, never corrects your call into one that runs, and never puts in a command what only someone else may do, such as the owner's answer or an approve; a step that has to come first, such as a question to the owner, is a command on its own line. A call that still holds one of Jarl's placeholders, wherever it stands (--root included), is refused, so a form pasted as printed writes nothing; any other text in angle brackets, such as <nil>, is a value like any other. The form keeps the --root and --json you gave as you gave them, also when you wrote them after a bare --, and it holds everything else the command needs, such as --by for who you are, so once filled in it is not refused for a part it left out. Every command Jarl prints, in a refusal, a note or a view, carries the --root you gave, and is written for a POSIX shell (sh, bash, zsh) on macOS and Linux and for PowerShell and cmd on Windows, every word quoted for that shell and every placeholder in double quotes, on one line; Git Bash on Windows reads those commands too, but for a path that starts with two backslashes. Replace every <placeholder> before running one.
  • A command that the status, the resume or a note prints for you to run, such as recording a CI result, reopening a task or ordering one task after another, keeps a <placeholder> wherever only you know the fact, and the owner's answer and tick always do. A line pasted as printed is refused and records nothing until you fill it in.
  • The tools show an example for the value field writes and its add and remove, the rows of evidence, the verdict and findings of review, decide's supersedes and the live view of decisions.
  • The note in the status and the report that merges land on testimony alone now shows the merge command in full, with the loop it belongs to.

Fixed

  • A research findings file with a misspelled field name is now refused, and the finding and the field are named, instead of filing the issue with that part left empty. A dry run refuses it the same way. A field name counts as misspelled when it differs from a field Jarl reads only in capital letters, when it is one letter off a name of five letters or more, or when two neighbouring letters are swapped; any other extra field passes, and the import lists the extra fields it let through.
  • models on a loop that has no issue yet, such as a fresh copy of a committed loop, now reports an empty loop. Before, it said the loop was missing.
  • A ruling recorded as the owner's now needs the owner's own words, which are kept with the ruling and shown beside it.
  • Every ruling written into an issue now says who made it. Jarl refuses any other text that spells out the line holding the owner's own words in a form it reads: capitals, accents, the look-alike letters on its list, hidden characters, other quotation marks, HTML codes and tags, and Markdown marks. A look-alike letter that is not on the list, or the line broken up by other words, gets through. A note that only looks like his ruling is free text and settles nothing.
  • Every tool now refuses a field it does not take, including the help tool, and names the fields it does take, so a misspelled field is never dropped without a word.
  • A merge recorded before its test run has finished now shows as waiting for its check in the status, the resume and the issue itself, with the command that records the check. It stops showing once the check, or the red check it landed on, is recorded. A task closed while its merge has no check recorded is named in the status.
  • Recording a merge now warns when the commit you give does not contain the branch's latest work or the latest state of the branch it is merged into, so a check that ran on the wrong version is noticed at once. That branch is the one the repository is declared with (base), and where none is declared, the one its main checkout has open. A squash or a rebase merge, which carries the branch's work without its commits, is named as such and not as a merge without the branch.
  • When a merge is recorded without its commit, Jarl now shows the latest commit of the issue's branch and the exact command that records it, so you do not have to look the commit up and retype the command.
  • When an issue cannot be finished because its latest review asks for changes, the message now names that review, with its reviewer and date, instead of a review round that was never recorded.
  • The first issue can be filed in a fresh copy of a loop that is kept in git, even when the loop had no issue yet when it was committed. Before, it stopped with an error about a missing folder.
  • After three failed rounds on a task, Jarl suggests a different model or a changed approach for the next worker, and never a level above the strongest. The suggestion names every model that has worked on the task, and offers no level up for a task whose level the loop does not list. The next suggestion comes after three more rounds, not on every round. A round can record how many findings it left, so a task that is getting better can be told from one that is stuck; a round that recorded none shows as a dash in its place.
  • Pausing a task and picking it up again no longer throws away its test results and its review, as long as nobody changed its code in between. A new change to the code still asks for new results and a new review.
  • Tags, files, issue numbers and the other lists can be given to the tools as a real list, and each item is stored on its own, so filtering by a tag finds the issue. A list typed out as text, in brackets with more than one item or with quotes, is refused with a message that says how to write it, and so is a tag or an issue number that holds a bracket or a quote mark, and any item that starts with a dash. A file name in brackets, such as [id], is kept as a path.
  • When a repository is kept by its path rather than by its name, Jarl explains why the first time it happens in a loop, and again if the reason changes. It no longer repeats the same explanation on every new issue that names the same repository.
  • Recording a merge now warns when the branch got new commits after its review was approved. The warning names the reviewed commit and the merged one, and gives the commands that show the difference and record a new review. The merge is still recorded.
  • resume and decisions show an answered question with its answer first, then the question.
  • models counts a model written with dots and the same model written with dashes, such as claude-opus-5.5 and claude-opus-5-5, as one model, and its row names both spellings. A review or a task that uses the other spelling gets a note naming the spelling the record holds.
  • A task that is approved and carries no code is no longer shown as queued for the merge in the status and the resume, where the merge queue never lists it. They now say that no merge waits and that it is ready to be set done.
  • set given the name of an issue's own field, such as Priority, Tags, Files, Repo, After or Source, now says it is a field and ends with the field call that writes it, as it does for a field the profile declares. Before, it listed the statuses.
  • When a new issue is filed with nobody named as having found it, the note on the empty field now gives the field call that sets it. Before, it said the name could only be given when filing.
  • Dropping or deferring an issue with a reason of blanks is now refused with the command that gives a reason, as a missing reason is. A changelog entry that opens with a word and a colon that is not a changelog section, such as Notes:, is now refused with the list of sections, so it no longer ends up as plain text in the release notes.
  • Every command that writes, run where no loop is found, now says there is no loop there and names --root as the way to point at one. Before, ask, log and decide stopped with a file error, and set, field and the others said there was no such issue.
  • A tool call refused for its input, such as a root that is not an absolute path, a field the tool does not take or a value of the wrong type, now ends with the call that tool takes, each value to fill in marked. list given a status, a kind or a priority the loop does not know is now refused with the values it knows, instead of showing an empty list.
  • A file written with a leading ./, a doubled or trailing slash, a . in the middle or, on Windows, backslashes is now the same file as the plain path. next and the leases hold an issue back on it, scope finds it in the diff, and field Files --add and --remove no longer add or miss it twice.
  • A new profile that declares a section named like a header field of an issue (such as Tags, Where or Priority), or Notes, Reviews or Proof, is now refused when you open a loop with it or check it, with the list of names it cannot take. Such a section would hide the field or let a write replace the history the issue shows. A loop you already run with such a section keeps it.
  • A new profile that declares a field named Title or Model, a field named like a part of a task's text or history (such as What, Evidence or Notes), or a field and a section with the same name, is now refused when you open a loop with it or check it, with the list of names a field cannot take. A loop you already run with such a field keeps it.
  • Only the owner can answer an item waiting for his approval. An answer recorded in anyone else's name is refused.
  • Importing research findings now checks every finding before it writes anything. If one cannot be filed, the whole file is refused, the finding is named and the loop stays as it was. Before, the findings ahead of it were already filed, or an issue already adopted, and a loop that cannot take a repository name wrote a change and then said nothing was written.
  • A findings file, a profile or a goal saved by an editor that puts a byte order mark at the start, as Windows editors do, is now read like any other. Before, a findings file saved that way was refused as not JSON.
  • An answer to an item waiting for the owner's approval must start with a word that approves or rejects it, such as yes or reject. Any other answer is refused, so it is always clear what the owner decided.
  • A finished task whose branch was deleted after its merge stays finished when a branch with the same name is made again later. Before, the task could show as missing its test result and its review.
  • A tool built on Jarl's record library can now name who changed a task's tags, priority, files or source, and the log shows that name.
  • When models, a check of a task's repository, a filing from a second copy of the checkout or a lock refuses and names the loop's folder, it now writes the folder in quotes, so a name with a line break or a shell sign stays on its line and runs nothing when the message is pasted.
  • When a repository has a declared base branch, the cleanup after a merge and a loop that closes tasks only on a landed merge now look at that base, as the note about the merge does. Before, they looked at the branch the main checkout had open, so the cleanup could delete the base branch and a task merged into the base could be refused.
  • The check of a worker's branch, the list of branches and the merge queue now measure the work against a repository's declared base branch too. Before, they used the branch the main checkout had open, so a branch merged only there could look finished.
  • A working copy whose folder path holds a line break is now known for what it is. Filing an issue from a second working copy of a loop is refused there too, as everywhere else, instead of filing into a copy that may be behind.
  • A task with code that is reopened, or sent back by a failed round, after its merge, or that gets new commits after it, can no longer be closed on that old merge: the merger records the merge of the code as it is now first. The status names a finished task that was closed on such a merge. A task merged once and never reopened closes as before.
  • Changing a long Where of a task now keeps only the first 120 characters of the old text and of the new one, and the length of each, in the log, as a changed section does. Before, the whole text went into the log.
  • The advice given to a worker who takes a task over no longer lists the folder on another machine where the earlier worker had its working copy.
  • The resume now shows each open question to the owner on one line, even one written over several lines. The question itself is kept as it was asked.
  • The resume also shows each choice waiting for the owner's approval on one line, even one written over several lines. The text itself is kept as it was written.
  • The status now shows each item to ratify on one line, even one written over several lines. The question itself is kept as it was asked.

6.2.0 - 2026-10-19

Jarl 6.2.0 makes the record of a loop more complete and more honest, and it keeps track of who did what. The file your assistant reads first is also shorter and clearer.

Before you upgrade

  • A loop, the record Jarl keeps of a piece of work, is marked with a new format the first time anything is written to it that an older Jarl would misread: a repository name, an issue or question number of 1000 or more, a retraction, or a new issue or question number below 100 written without leading zeros (3, not 003). A new loop, or any loop with fewer than 100 issues, is marked at its first new issue or question.
  • From then on every copy of Jarl that touches that loop must be this release, including copies of Jarl installed in assistants in other sessions and other copies of the project. A copy of the previous release refuses such a loop with a clear message instead of misreading it.
  • Nothing is migrated. Loops are read as written, with two exceptions. A repository path written as a bare word, such as sub, becomes ./sub when the loop is first marked, with the same meaning. A status, lease, merge or build-check line that was only edited by hand in an issue file no longer counts: the log is the record now, and such an edit does not move the issue.
  • Recording a merge no longer sets the result of the build checks to pending. Add --ci <state> when you want one; a tool built on Jarl's record keeps the old default.
  • merged now deletes the issue's worktree and its branch on this machine when that is safe. --keep stops it.
  • show prints the part of an issue that matters, and show <id> --full prints everything. next lists only what can start now, and next --all lists the rest.
  • The assistant tools no longer include handoff. Start a session from resume.
  • review refuses findings of fewer than three words, so LGTM no longer passes; say what was read and what was found.
  • close refuses while any issue is deferred. Use archive to keep the work, or close --force to remove it; a permanent loop keeps its record and lists the deferred issues.
  • An answer to a question that waits for the owner's ratification must say who gave it, with --by.
  • The handoff entry in status --json and the legacyHandoff entry in resume --json are no longer part of the documented output. They are still printed.
  • The file your assistant reads first is now short, with a references directory beside it. A plugin install gets both. If you copy the skill by hand, copy the whole directory.

Added

  • An issue can need files before it is done, such as a picture before a fix and one after it, and Jarl will not close it until they are there.
  • A new command, verify, checks that a loop's record is in good order and changes nothing.
  • A wrong verdict, the reviewer's decision, or a wrong piece of proof can be taken back with retract. The original stays visible, struck through, with who took it back and why.
  • Jarl keeps which model did each piece of work and which model reviewed it, and models shows how well each one did.
  • A loop can name its repositories, so the record holds nothing that belongs to one machine.
  • A question can offer choices, and several questions that wait for ratification can be answered at once.
  • Status, resume and report list a closed issue whose conditions for being done no longer hold, such as a proof that was taken back, with the command that repairs it.

Changed

  • status and resume say what each issue in progress is waiting for.
  • There are three tiers of worker, light, standard and strong, and standard stays the default.
  • A new lease, the claim an issue holds while it is in progress, no longer records where its worktree is. Jarl finds the worktree through the branch.
  • Issue numbers are plain: 7, not 007. Both mean the same issue, so type either.
  • check is now scope, and check still works as a name for it.
  • set <ids> <field> "<value>" still writes a field and an empty value still clears it, with a note that points to field. field writes only Resources and the fields a loop's profile declares; the other fields keep their own commands.

Fixed

  • Long findings and notes are kept whole instead of cut to their first line.

6.1.1 - 2026-10-13

Fixed

  • Jarl's tools now start in Cursor, from an entry of the plugin made for Cursor.

6.1.0 - 2026-09-29

Jarl 6.1.0 lets one loop drive work across several repositories, keeps the loop out of your git history by default, and starts each new session from a single resume. Your agent reaches every command as an MCP tool, and the record gets firmer: an issue closes on recorded proof, and code on a fresh reviewer's approve. Jarl now shares one version number with the rest of the Yggdrasil family's core (Yggdrasil, Grain and Horde), so it moves from 0.1.0 straight to 6.1.0. Under that shared number a minor release can carry upgrade steps, and this one has a few.

Before you upgrade

  • Jarl runs on Node.js 22 or later (0.1.0 ran on Node 18). Install Node 22 first.
  • New loops stay out of git: init has git ignore .jarl/, and worktrees of the same repository still find it. To carry a loop to another clone or machine, open it with init "<goal>" --committed, which keeps it on the branch as 0.1.0 did. Loops opened with 0.1.0 stay committed.
  • set <id> done closes an issue once it has a --ran/--saw evidence row recorded since it last went in progress or was reopened; a free-text note, a ruling or a drop or defer reason does not count on its own. An approve holds until the next red round, reopen or restart. Record a row with evidence <id> --ran "<command>" --saw "<output>" before you close. Issues already done stay done.
  • Every review names its reviewer with --by <reviewer>, and Jarl refuses an approve from anyone who worked the issue or its branch. An issue that records a branch or a merge closes on a fresh reviewer's approve, from someone who neither wrote the code nor runs the loop; the coordinator (jarl, reeve, coordinator, the loop's directory name, or a name on a Coordinators: line in goal.md) closes rulings and documents. Raise a fresh reviewer for every branch.
  • The command line checks its input: it refuses an unknown flag or an extra argument with exit code 1, and for a flag it names the ones the command takes. A value starting with -- belongs to the flag before it; a note or title starting with -- goes after a bare --. decide takes slugs of letters, digits and . _ -, and ask --issue takes an existing issue. Adjust any call the tool refuses.
  • resume takes over from the handoff and assembles the state live. handoff write succeeds and writes nothing, handoff read prints what resume prints and needs a loop, and status leaves out the handoff's age. Start sessions from resume.
  • report prints "Found along the way" when you pass --found. Add the flag wherever you want that section.
  • The journal's review line reads NNN review approve · by <name> (<kind>) · <findings>. Update anything that parses it.

Upgrading from 0.1.0

  1. Install Node.js 22 or later.
  2. Update the plugin. In Claude Code: /plugin marketplace update jarl-marketplace, /plugin install jarl@jarl-marketplace, then /reload-plugins; the README covers Copilot, Codex and Cursor. A drop-in copy takes the whole skills/jarl/ directory.
  3. A loop opened with 0.1.0 carries on as a committed loop. On its first write, Jarl adds an ignore file and merge settings inside .jarl/ and a merge driver to the repository's local git configuration. Commit the new .jarl/ files with the loop.
  4. Bring scripts and agent instructions that call the tool in line with the list above.
  5. To have ratified rulings written into Yggdrasil's logs, use Yggdrasil 6.1.0 or later. With an older yg, Jarl prints the command to run by hand.

Added

  • One loop can drive work in several repositories. Name the repository root on the issue (new --repo <path> or repo <id> <path>) and its files carry that repository's name first (tool/src/a.mjs, or app/app/x.mjs when the repository holds a directory of its own name). next, check, resume, report and the other views follow the issue there.
  • From any worktree of the repository, the tool finds the loop without --root.
  • resume gives a new session everything in one read, from the goal and the rulings in force to the work in flight, the merge queue and CI. It writes nothing and needs no network unless you pass --ci.
  • init "<goal>" --permanent keeps a loop after close as a record, and mode permanent turns a committed loop into one. archive "<slug>" puts a finished loop away so a new one can open in its place, and set <id> deferred "<why>" parks work that waits on someone.
  • A committed loop merges cleanly when two branches carrying it meet, and stops with conflict markers when both changed the same ruling. merge-driver flags prints the settings for git merge.
  • Fuller issues. new --where --what --why --acceptance and body <id> write the body, after <id> <ids> orders issues, new --template <name> starts from a template, and --changelog "Added: …" keeps the issue's changelog entry until changelog <ids> prints it at merge time. evidence, review, set, tag and prio take id lists such as 203-206, all or nothing.
  • Branches, merges and CI on the record: set <ids> in-progress --branch <b> leases a package of issues, merged <ids> --sha <sha> --ci <state> records a merge, queue shows the merge queue, and tips shows each repository's branches with their CI. None of them blocks a merge.
  • report ends with loop metrics: cycle and lead time, rounds, reopenings, the share of fresh reviews, red CI after a merge, and follow-ups. A Check: <command> line in goal.md names the check that decides what lands.
  • Rulings can supersede one another (decide --supersedes, decisions --live), and ask --kind ratify records a choice that waits for your word. decide --area <type> --reach <n> marks a ruling for every file of a type; close puts these to you in one batch and, in a repository with a Yggdrasil graph, writes each one you ratify into that type's decision log. Add --rule <id> to name one of the graph's rules, and your yes also ratifies that rule in Yggdrasil so it can stand enforced, for every type the rule reaches.
  • import <findings.json> files one issue per research finding, once, and sources shows what was filed.
  • An MCP server starts with the plugin. Every command is a tool with the same arguments, marked as writing or read-only, and the whole list costs an agent about 7,000 tokens. JARL_ROOT, if you set it, takes an absolute path.
  • Profiles let a tool such as Horde run its work as Jarl loops: init "<goal>" --profile <file> sets statuses, fields and sections, and can hand scheduling, the done check, close and archive to that tool.
  • A versioned library, jarl-record/1, lets a tool read and write a loop without the command line.
  • JSON for dashboards: status --by repo|tag|kind|prio, more counts in status --json, one row per issue in report --json, and waitsOn and after as lists on every next --json row. The skill documents these shapes as stable.
  • Jarl runs on Windows, checkouts with Windows line endings included, and Copilot and Codex can install it from a portable Agent Plugins 1.0 manifest.

Changed

  • branches without --repo covers every repository an open or in-progress issue names, and marks stale leases and branches ready to delete.
  • A line in goal.md's rules, or a ruling, can give standing permission to push the feature branch; the merger then pushes it after each green merge. Worker branches stay local.
  • Where a helper agent cannot start agents of its own, the loop notices at the start and relays every spawn through files, second rounds included.

Fixed

  • Workers, reviewers and the merger can write at once: each write waits its turn behind a lock, so every evidence row, log line and issue number lands.
  • Evidence grows line by line: a note, a drop reason and each --ran/--saw pair add a line of their own to what the issue already holds, text with $& or $1 included.
  • check counts a file an issue names relative to a subdirectory as in scope.
  • The merger also removes the branch a worker started on when the platform created its worktree.
  • Titles with ł, ø, ß and similar letters give readable file names: gałęzi becomes galezi.
  • In a dev container handed the host's install path, the skill uses its own copy of the tool, or stops if there is none.

0.1.0 - 2026-09-13

Added

  • The jarl skill. Invoke /jarl <goal> on a feature branch and the agent becomes the director of that branch: everything anybody sees becomes an issue in a committed .jarl/ directory, one worker per issue works in its own worktree, nothing merges without evidence the agent has reproduced itself, and the directory is removed by the last commit before the branch merges to main. Testing, stress and research sessions run on the same loop, with some workers producing issues while others take them down.
  • One small tool, jarl.mjs, that every change of state goes through: file an issue, list and search by status, kind, tag, priority or text, change a status with its reason written to the journal in the same move, tag and prioritise, ask the user a question of one of four closed kinds (stop, stuck, lower with a named target, charter) rather than free text, record evidence — free text, or a repeatable checkable row naming the command and what it printed —, record a review verdict where "changes" must name a Critical or Important finding (Minor alone rides an approve instead of bouncing the branch), ask what can run in parallel right now, count red rounds and hand an issue to a fresh worker after three, check a worker's branch before merge (commits, files outside the declared scope, test files removed, assertions before and after), list worker branches with unmerged commits, file questions only the user can answer and turn their answers into rulings, write a handoff for the next session, produce the closing report, and close the loop; its worker guidance now steers a scratch copy over git stash for holding work aside, since the stash list is shared across every worktree of a repository, and never checks out a ref in the main checkout — the merger alone moves it, and now confirms each done actually landed before moving to the next branch; the loop now treats a merger's own report as the only signal it has stopped touching the main checkout, after a rewritten HEAD surfaced when that was assumed instead of confirmed — which refuses while anything is still open. Node, no dependencies.
  • Three standing helpers the loop raises so the director's own context is spent on the client: a reeve that runs the loop day to day and reports back on four occasions only, a fresh reviewer per branch, and a merger that verifies and merges one branch at a time. Worker branches are named by issue and never leave the machine.
  • Installable as a Claude Code plugin, a GitHub Copilot CLI plugin, a Codex CLI plugin and a Cursor plugin, or as a single file dropped into any agent's skill directory.