orchestrating
Skill2 starsChanged 21 days agoMITView on GitHub
Use when starting a session in this repository, starting or resuming a batch, or dispatching any subagent
- Deletes or force-pushes
4 other projects use a version of this.
Adopted by
Most recently taken up by
- h3y6e/agent-skillstheir own version, first seen Nov 8, 2026
- yahyabedirhan/skillstheir own version, first seen Oct 18, 2026
- syntropic137/syntropic137their own version, first seen Oct 13, 2026
- renathoaz/arsyntheir own version, first seen Mar 24, 2026
Other versions4 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 4
- syntropic137/syntropic137★ 5same name
- yahyabedirhan/skills★ 3same name
- renathoaz/arsyn★ 2same name
- h3y6e/agent-skills★ 0same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository12 other files it gives its agents.
- AGENTS.mdAGENTS.md
- template/AGENTS.mdAGENTS.md
- tests/AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- template/CLAUDE.mdCLAUDE.md
- designingSkill
- finishing-a-featureSkill
- houserules-stepSkill
- migrating-knowledgeSkill
- planningSkill
- project-knowledgeSkill
- readme-reworkSkill
The file
We split this skill into the rules it gives an agent
12 rules. 0 are common, 3 are distinctive, and 9 are very specific to this project.
0
Common
Most of the 3 edited versions we read keep these.
3
Distinctive
This author's own choices. Worth a look.
9
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 15
Run the start command of the Session section in the houserules block of AGENTS.md.
- Very specific: line 16
If a plan is in flight: read the ledger progress.md in the batch workspace.
- Very specific: line 76
When the project has a coverage gate, the full-suite run at integration measures it.
- Very specific: line 78
Run each controller-run integration gate through houserules capture, and put any injected configuration in the argv, so that the capture …
- Very specific: line 79
After you integrate a task, remove its worktree and its branch: git worktree remove <path>, then git branch -D <branch> (the cherry-pick …
- Distinctive: line 81
Run at most three agents at once unless the plan sets a lower limit.
- Very specific: line 89
Every dispatch carries a Model: <alias> line, an implementer dispatch included.
- Distinctive: line 111
Ask the project's owner or decider in a plain message, never in a question tool that holds your turn.
- Distinctive: line 114
When a batch edits an agent template or skill, the dispatch message carries the changed instruction verbatim: templates load at session …
- Very specific: line 123
Every finding is fixed (process.no-tech-debt).
- Very specific: line 136
Before the branch review dispatches, or before Finish in a batch without one, confirm every task-*-report.json in each workspace has a …
- Very specific: line 150
When the branch changes the houserules binary, replace houserules in the brief with the path of the binary built from the branch.
“Common” is measured: kept by at least 6 in 10 of the 3 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Orchestrating a batch
You are the controller. Subagents get knowledge through their templates; you get it through this skill, the standing rules, and houserules. Every read command prints JSON. Write each output to a file in the batch workspace, and read the file with your file-read tool (houserules list --open > <workspace>/open.json). Treat a << marker or a "more items" note as a lost read and read the source file.
The batch workspace is the folder <YYYY-MM-DD>-batch-<n> of the workspaces location (default .houserules/work/). A project sets another location with the workspaces key of .houserules.json. The folder holds the deliverables of the batch and its ledger, progress.md. Git ignores the default location; houserules check-knowledge fails an entry whose verify path names a file in any ignored location, the default included: commit a copy under a tracked path and verify that.
Session ritual (session start, resume, and after compaction)
git status --short && git log --oneline -15- Run the start command of the Session section in the houserules block of
AGENTS.md. Then runhouserules list --batch <n>for the in-progress batch, orhouserules list --openwhen none is in progress. At the end of a session, run the end command of the same section. - If a plan is in flight: read the ledger
progress.mdin the batch workspace. Trust the ledger andgit logover memory. houserules index --area process;houserules getwhat the next step needs. The process index lists every process rule, standing or not: it is how a non-standing process rule reaches you (knowledge-base.rules-need-a-loading-path).- Re-read the spec and plan in flight before the next dispatch.
Batch lifecycle
| Phase | Skill | Repo gate |
| Select items | — | houserules list --open; record the batch (the paragraph below the table gives its record) and schedule its items (houserules set <id> batch=<n>) |
| Design | designing | spec in docs/specs/; design review by the spec-reviewer (standard tier); approval from the project's owner or decider |
| Plan | planning | plan in docs/plans/; code-health scan of the touched files (process.code-health-scan); technical-debt candidates; approval when asked |
| Build | — | the dispatch protocol below; close the phase's cost window when the phase ends, where the project keeps one (Batch close) |
| Verify | — | live run before any pull or merge request or deploy spend (process.live-run-before-ci); a printed command or line that changes after the live run runs again before the branch review; close the phase's cost window when the phase ends, where the project keeps one (Batch close) |
| Finish | finishing-a-feature | backlog ticked, one to five clean commits, the evidence bundle (houserules bundle write) in the description of the pull or merge request, checks, merged per the project's own discipline |
| Rollout, acceptance | — | acceptance from the project's owner or decider; the acceptance record and new rulings ride the next branch |
The batch record keeps the batch's number, summary, kickoff, and status. The tracker decides where it lives:
- JSON: an entry of
backlog/batches.json. - GitHub: an issue labelled
houserules:batchand titledBatch <n>: <summary>. A fencedhouserulesblock at the end of its body holdskickoffandstatus, for examplestatus: {"state":"in-progress","text":""}. The issue is open while the batch is planned or in progress, and closed when it is done. - Beads: an issue of the custom type
houserules-batch, with the same title and block.
No houserules command writes a GitHub or Beads batch record: create and edit the issue with gh or bd. houserules set <id> batch=<n> schedules an item on every tracker.
Tiers
The change's risk picks the tier at plan time (process.risk-tiers). You pick between two tiers, light and standard. Every tier runs Select items, Verify (the live run), Finish, and Rollout and acceptance. A lighter tier changes only what its pipeline column names. The re-review cap per task differs by tier.
| Tier | Selected when | Pipeline |
| light | one task; docs, comments, config values, or a dependency bump; no executable behavior change; no task is critical | the backlog item's body is the spec (the project's owner or decider still approves it); implementer; one task review; controller live run. No design review, no plan document, no branch review. |
| standard | every change that is not light | short spec with a design review, and approval from the project's owner or decider; plan; implementer; one task review and at most one re-review; controller live run; branch review only for a batch of two or more tasks |
A critical task is a task whose change alters the CLI's commands, flags, or output, a schema, authentication or security code, or the data on disk of an install. It runs inside the standard tier with its own evidence:
- The plan writes the spec's cases for the task as tests before any code.
- The implementer commits those tests first, with one recorded run that shows them failing at
BASE, then makes them pass. It still works test-first for every further change. The evidence is that run and the whole suite passing atHEAD. The whole-suite half is the integration run of the person who runs the work. - The task gets one task review on the task reviewer's configured model (default opus). It gets no re-review of its original findings.
- You verify each fix by re-running the reviewer's own reproduction, and you record the check in the ledger (
process.fix-round-verification-record). A Critical or Important finding goes to a fresh implementer. You fix a Minor finding yourself. - A fix round that fixes a Critical or Important finding, or that changes files beyond the files its findings name, then gets one review of its fix diff. That review files only new breakage. Only a new Critical or Important finding of it opens a further round, which closes by your check, with no second fix-diff review (
process.risk-tiers).
The tier rules:
- The plan records the tier and the criterion that selected it. A light change has no plan: the dispatch brief records both.
- One tier covers the batch: the highest tier that any of its changes needs. A critical task follows its own evidence rule inside that tier.
- A tier moves up during a batch, never down. A light task with an Important or Critical finding moves up to standard (
process.bounded-review-loop). - The task reviewer checks the tier. A wrong tier is a finding.
Parallel and sequential dispatch
Dispatch agents in parallel only when the plan marks their tasks parallel (process.parallel-on-disjoint-files). Dispatch every other agent sequentially: never start a second one before the last one closes.
- Mark tasks parallel in the plan when their declared file sets are disjoint and no task needs another's output. You own the files that many tasks regenerate: the generated rule files and skill (
houserules render),backlog/, lockfiles, and any other file that a build or sync step regenerates. A parallel task does not touch them. You regenerate them at integration. - Give each parallel implementer its own git worktree, on its own branch from the same
BASE. - Open the brief of a dispatch into a worktree with a first act. The implementer runs
git merge-base --is-ancestor <BASE> HEADin its worktree. When the command exits 0, the worktree holds<BASE>, and the implementer goes on. When the command exits 1, the implementer runsgit reset --hard <BASE>and records the reset inconcerns. When the command exits with any other status, the implementer stops and reports BLOCKED with the output. In a fix round,<BASE>isFIX_BASE. Leave the first act out of a dispatch into a shared checkout, where a reset discards work. - Name each parallel agent's scratch root in its dispatch,
<scratchpad>/task-<N>/, and tell it to write scratch files nowhere else. Every agent of one session gets the same scratchpad path, and two agents that write one file name there overwrite each other without an error. - Integrate a finished task onto the batch branch one at a time (cherry-pick). Run the gates after each. Write the old-to-new commit map to the ledger. A conflict or a red gate at integration is a fix round for the later task, except a conflict in a file that the plan names as shared.
- A file that the plan names as shared may conflict at the later cherry-pick. Resolve that conflict by keeping both sides, and run the gates. Any other resolution is a fix round for the later task.
- Run the full suite, and every suite the plan marks as integration-only, once per integration. An implementer's run and a fix round run the tests of the files they change instead. Two independent integration suites may run at once. Independent suites share no output directory.
- A task that you dispatch into a shared checkout has no cherry-pick: it integrates when its implementer closes. A sequential task, the one task of a light batch, and each fix round of such a task integrate this way when they run in the shared checkout; a task in a worktree integrates by its cherry-pick. At that close, run the full suite and every suite the plan marks as integration-only, before you dispatch the next task. A red in that run opens a fix round for the task.
- When the project has a coverage gate, the full-suite run at integration measures it. Write the measure into the
coveragefield of the task report: one measure per target, withtarget,metric,measured, andfloor. The implementer leaves that fieldnull. - A gate command that the harness refuses to an agent is a controller-run integration gate: the plan lists it, and you run it after each integration and record it in the ledger.
- Run each controller-run integration gate through
houserules capture, and put any injected configuration in the argv, so that the capture shows it:houserules capture --out <workspace>/<name>.txt -- env GIT_CONFIG_COUNT=1 GIT_CONFIG_KEY_0=core.autocrlf GIT_CONFIG_VALUE_0=true <gate command>. - After you integrate a task, remove its worktree and its branch:
git worktree remove <path>, thengit branch -D <branch>(the cherry-pick leaves the branch unmerged, so-drefuses). A worktree that stays makes your harness load its copies of the skills and templates as duplicates. - Reviews of different tasks may run at the same time: reviewers do not write to the tree. The review of a task starts after its implementer closes.
- Run at most three agents at once unless the plan sets a lower limit. The ledger records each dispatch's start and close, each with its UTC time. Read the time from the clock in the command that writes the line.
- A wave orders the tasks; it is no barrier. A task starts as soon as every task it needs is integrated. A task that consumes only an interface that no open finding changes starts from an interim base that holds the commits of the task it needs. You integrate the commits of the consuming task alone, after the task it needs closes.
A project may rule its own parallelism discipline (elicited by the migrating-knowledge skill's "Elicit your own operating discipline" step, recorded as its own knowledge entry); that ruling replaces this default. A line from a kit before 1.3.0 that says to hand off or dispatch tasks sequentially by default states the old kit default, not a project ruling. houserules update never rewrites such a line, so remove the sentence by hand. It sits in AGENTS.md outside the houserules block, or, in an install seeded by the 1.0.0 kit, in CLAUDE.md. While the workflow is installed, the houserules block of AGENTS.md carries the current rule: run handoffs in parallel only when the plan marks their file sets disjoint, each in its own worktree. The 1.0.0 line in CLAUDE.md also carries the dispatch-template and the Knowledge: and BASE: instructions: delete only its sentence Dispatch agent work sequentially by default, until the project rules its own parallelism discipline., or move your own text into AGENTS.md and leave CLAUDE.md as the one line @AGENTS.md.
Dispatch protocol
- Templates:
implementer,task-reviewer,branch-reviewer, andspec-reviewer;houserules init --workflow referenceinstalls them. Each role's model is a configuration value:workflow.modelsin.houserules.jsonholds it, and the defaults are sonnet for the implementer and opus for the other three roles. A template carries nomodel:line, so a dispatch that names no model runs on your own session's model. Read the role's value, pass it to the dispatch, and check that the dispatch names one before you send it. Reviews run on a mightier model than the implementer they review by default (process.model-policyis a recommendation the project may override). - Every dispatch carries a
Model: <alias>line, an implementer dispatch included. A report from a dispatch with noModel:line recordsunknownas its model. - Derive a dispatch's commit span with
git rev-list --count BASE..HEAD; never hand-type a count into a dispatch or its ledger row. - Paste every sha of a dispatch from the output of git rev-parse in the same turn; never retype one.
- An implementer dispatch is the task brief plus these lines:
BASE: <sha>— the commit before the task.Backlog: <ids the task delivers>— the implementer writes oneWork-Item: <id>trailer per id on every commit.Tier: <light|standard> (<criterion>)— the tier and the criterion that selected it (process.risk-tiers). A critical task says so in the criterion, for exampleTier: standard (critical task: it changes a schema).Model: <the role's model>— the model the agent records in themodelfield of its deliverable.Knowledge: <ids>—houserules for <the brief's files>plus the procedure ids the task needs. Five to ten ids. Leave an entry taggedcontrolleroff the line unless the task needs it: a task audit keeps it in the package when the line names it (knowledge-base.controller-rules-are-tagged).REPORT_FILE: <workspace>/task-<N>-report.json
- A reviewer dispatch adds
BASE,HEAD, the sameBacklog:,Tier:, andKnowledge:lines, its ownModel:,REPORT_FILE,REVIEW_FILE: <workspace>/task-<N>-review.json(re-review:task-<N>-review-r<R>.json),AUDIT_JSON: <workspace>/task-<N>-audit.json(re-review:-r<R>), and the audit command's--ids <the Knowledge ids>. - A spec-review dispatch names
TARGET: <spec path>,BASE,HEAD, the batch'sBacklog:ids,Tier:,Model:,Knowledge:(the four design-phase ids and the ids the spec rests on), andREVIEW_FILE: <workspace>/spec-review.json. A fresh review after a Critical finding writesspec-review-r<R>.jsonand names the earlier reviews asPRIOR:. - The audit
--idsvalue is the dispatch'sKnowledge:list, generated from it, never typed separately — true for round 0 and every re-review alike. - A re-review dispatch carries the identical
Knowledge:/Backlog:/--idsblock as the round-0 dispatch, and the task's currentTier:line. A narrowed block narrows the audit package silently. - A fix-round dispatch names
FIX_BASE; the fix-diff audit goes into the report'sfix_roundsentry, andself_auditstays theBASE..HEADaudit (process.deliverables-json). - A parallel task's fix round commits in the task's own worktree on its
FIX_BASE, because a worktree-isolated agent cannot run git against the shared checkout. You cherry-pick that commit, run the gates, and extend the ledger's commit map. - A fix-round dispatch quotes a finding's premise only with the review's own named verification run beside it; a premise with no such run gets no free pass — the dispatch tells the implementer to measure it first, before acting on it. Relaying an unverified premise as fact produces a correction that can itself be false.
- The branch review dispatch names
WORKSPACE(every workspace of the batch, when it has several),BASE(the merge base),HEAD,Model:, the plan and spec paths, andREVIEW_FILE: <workspace>/branch-review.json, throughbranch-reviewer; its audit runs--workspace <WORKSPACE>in place of--report, once per workspace, each run writing<that workspace>/branch-audit.json. - A brief names no version number for a tool, action, or package (
security-hygiene.exact-pins); it names the verification the implementer runs and records indocs_verified, and shows placeholders such asjdx/mise-action@<current major>. - A brief names every test, gate, and file its spec task lists, verbatim or by pointer (
process.brief-carries-the-spec); an implementer who cannot satisfy one flags it instead of dropping it. - A brief that forbids tree changes names who files its deferrals: you, by default. The implementer then lists each deferral in
concernsand runs nohouserules defer. - A brief rules every reading that the spec leaves open and that a test would pin. Find each one when you write the brief, and rule it there. When an implementer returns NEEDS_CONTEXT with a reading, rule it and resume the task.
- Ask the project's owner or decider in a plain message, never in a question tool that holds your turn. Keep dispatching every task and fix round that needs no ruling. Send the ruling to the waiting agent when it arrives.
- A brief for a task that adds or tightens a check in
check-knowledge,check-backlog, orauditcarries a paper walk: a fresh install, an install on each released kit under the new binary, an install with kept or overridden kit-owned files, and each author class of commits. The report states each accepted red. - A brief's claim about a file's current contents is measured at brief-writing time — grepped or read, never restated from memory or an earlier document; an unmeasured claim about a knowledge copy or a file's shape is exactly the kind of thing that can be flatly wrong, and the implementer pays the disproof. A brief that dictates a message reads it once for each state that prints it. A brief that dictates an enumeration derives it from the subject, never from a file name. A brief that dictates a mechanism that a reviewer proposed has run it against the reviewer's own counter-example first.
- When a batch edits an agent template or skill, the dispatch message carries the changed instruction verbatim: templates load at session start, so the running session's copy is stale until a restart.
- A controller commit made while a task is open (a concurrent backlog filing, a rulings-to-file write) touches only files disjoint from the open task's own files; record it in the ledger before the next reviewer dispatch, and name it in that dispatch.
Handling reviews
- A review that fails
houserules validate(anopenrow included) or is not atREVIEW_FILEwith itsAUDIT_JSONis incomplete: re-dispatch it.houserules statsreads only files at those names: everytask-*-audit*.json,task-*-review*.json,task-*-report.json,branch-review.json,spec-review.json, andspec-review-r<n>.jsonin a workspace. - A branch review's audit runs
--workspace <WORKSPACE>: itsreport-fieldrows are judged from every task report, not skipped. - When you or the project's owner or decider rule against a reviewer's verdict on a judged row, record the ruling on that row of the review file as
override:{ "result": "pass" | "fail", "by": "<person or role>", "reason": "<text>" }. The reviewer'sresultstays on the row. You write theoverride; a reviewer never writes one.houserules statsreads it into theoverride_rateof the rule. - Severity follows impact, not the rule's class (
process.severity-by-impact). Critical: wrong behavior on a shipped contract, a security exposure, data loss, a gate that passes when it must fail, or fabricated evidence. Important: a missed requirement, incorrect or fragile behavior, maintainability damage you would block a merge over, or a misstated claim that the merge decision relies on. Minor: everything else, narrative report prose included. - Every finding is fixed (
process.no-tech-debt). A deferral is a backlog item with a reason, named in the finding. - Bound the review loop (
process.bounded-review-loop). A fix round that holds only Minor fixes closes with a controller verification note, never with a re-review. A re-review reads the fix diff and the original findings only, and only a new Critical or Important finding opens a further round. The cap on re-reviews per task is the tier's: light 0, standard 1. A critical task gets no re-review of its original findings, and one review of its fix diff after a fix round of the kind thatprocess.risk-tiersnames; the task reviewer writes it astask-<N>-review-r<R>.json. A branch-review fix wave has the cap of the batch's tier. At the cap, the open non-critical findings become one backlog item with the reason, and an open Critical finding goes to the project's owner or decider. A light task with an Important or Critical finding moves up to the standard tier and gets its one re-review. - While a fix-diff review or a re-review runs, you may integrate the fix and run the integration gates. When the review files a new Critical or Important finding, undo the integration (the batch branch returns to the commit before it) and open the next round for the task.
- A fix round closes in one of two recorded forms: a re-review deliverable in the workspace (the default for executable changes or any critical finding), or a controller verification note in the ledger naming each finding and the artifact proving its fix (sufficient for a round that holds only Minor fixes, whatever the kind of change, and for report-only or prose rounds) —
process.fix-round-verification-record. In a note, run the check that each Minor finding names (name one yourself when a finding names none) and cite its result. Confirm that the round'sgates_runlists the whole gate set of the task, not only the gates the round touched. When an implementer contests a finding because itsfixadds a capability with no caller, rule in one of three ways. The contest holds: drop the finding and record the reason in the ledger. Defer: file a backlog item that the finding names. The contest fails: the finding stands, and the implementer fixes it in the next round. - Ledger line per task:
Adherence: <pass>/<fail>/<warn>; judged fails: <ids or none>. - A plan's factual claims about where things live cite the enumeration that found them; the branch review re-derives them like report claims. In a batch without a branch review, you re-derive them before Finish.
- Log every controller slip that forces a re-run, an amend, or a correction — gate-caught or not — to the batch workspace ledger when it happens (
process.gate-shell-chains). - On a mid-batch branch rebuild, keep the old branch under a new name, write the old-to-new sha map to its own workspace file, cite both in the batch report, and never edit closed-task deliverables (
process.main-wins-backlog-collisions).
Batch close
- A project that measures the cost of its batches keeps
<workspace>/efficiency-windows.json: one window (phase,start, andend, in UTC) for each phase. Close the window of a phase when the phase ends, as the Build and Verify rows say. A window rebuilt from commit dates says so in its phase name. - Before the branch review dispatches, or before Finish in a batch without one, re-read the declared file set of each task (its Files line) and the plan's Global constraints, when it has them, against the tree. Add a revision note to the plan for each sentence that no longer holds (the
planningskill, "Keep the plan true"). A batch with no plan has nothing to re-read. - Before the branch review dispatches, or before Finish in a batch without one, confirm every
task-*-report.jsonin each workspace has a ledger row stating its close commit and round count. - In a batch without a branch review, run
houserules audit --base <merge base> --workspace <WORKSPACE>before Finish, once per workspace, and judge itscontrollerrows in the ledger: a task audit leaves them out (knowledge-base.controller-rules-are-tagged). - Run
houserules stats --window 5 <WORKSPACE>...with every batch workspace, this batch's included, and save the output as<workspace>/stats.json(process.knowledge-earns-its-place). The flag keeps the five most recent of the workspaces you name, and every workspace when fewer than five exist. Run it before the branch review dispatches, or before Finish in a batch without one: the branch reviewer reads that file. A batch with no branch review reads theproposalskey itself. Once a backlog item cites a stats file, never overwrite that file: save a later run under a name that states its window,stats-batches-<a>-<b>.json. - Apply every
proposalsrow withowner_gate: falseof the batch-close run in onedocs(knowledge): ...commit, and apply the retrospective proposals of the branch review in the same commit, except a proposal that adds or changes a standing entry or changes an entry whosesource.byisuser. Make that commit after the branch review closes, or before Finish in a batch without one, so that a row which only the batch-close run draws is applied too.retiresetsstatus: retiredand, for a local entry, runshouserules archive. A pack entry stays in its pack copy: aretire,demote, ornarrowproposal for it is an override inknowledge/overrides.json, andretireis an override withstatus: retired.demotedropsstandingand gives the entry an area.narrowrewrites the entry's scope.mechanizefiles a backlog item for the check. - List every
owner_gate: truerow, and every retrospective proposal that the previous bullet excepts, in the batch report for the project's owner or decider to rule on. - When the project's owner or decider rules to keep an entry that a proposal names, add the tag
ruled-keepto the entry, so the loop stops proposing it (process.knowledge-earns-its-place). Aruled-keepentry gets nodemote,retire,narrow, ormechanizeproposal. It still counts toward the standing budget. - A pack entry that the project retires, demotes, rewrites, or tags
ruled-keepis an override inknowledge/overrides.json, andhouserules updatekeeps the override. - A new retrospective entry defaults to a non-standing area entry. A new standing entry names the standing entry it replaces, or the budget headroom from the latest
statsrun.
Template evaluation
- A change to
.claude/agents/implementer.md,.claude/agents/task-reviewer.md(both installed byhouserules init --workflow reference), or.claude/evals/*.jsonneeds a run of every scenario in.claude/evals/before the branch review, or before Finish in a batch without one (process.evals-rerun); the audit fails until.claude/evals/record.jsonchanges with them. - Run each scenario in a detached scratch worktree at the branch head: implementer scenarios through
implementerwith the scenario'squeryas the brief file, aBacklog:line that names one item of the scratch tree, and itsknowledgeas theKnowledge:line;seeded-violationsthroughtask-revieweron a fixture built from itssetup. Each dispatch names its role's configured model. Workspace artifacts carry theeval-prefix; keep nothing from a worktree. - Each scenario brief names the command that runs the suite with the project's pinned tools: the test task of the project's task runner. When the project has no such task, the brief names the test command of the plan's gate list, or, in a batch with no plan, the test command that the project documents.
- When the branch changes the houserules binary, replace
houserulesin the brief with the path of the binary built from the branch. - Judge every
expected_behaviorline from the report or review. Append one run set to.claude/evals/record.json:date,templates(git rev-parse HEAD:<path>for both templates),runs(scenario,agent,model,pass,of,notes). - An empty
.claude/evals/record.jsonis the state of a fresh install. The first run set you append is the baseline; it is due at the first batch that changes one of the two templates or a scenario. - Commit a
houserules updateon its own, outside a batch branch. An update can change the two templates without an eval run of the batch, and the audit of a batch branch that holds such a change failsprocess.evals-rerun. The kit release carries its own eval run.
Rulings
Write every ruling to its home file in the same turn (process.rulings-to-file), then houserules render. A ruling that lives only in chat is lost at compaction. A decision that makes a sentence of the plan false adds a revision note to the plan in the same turn (the planning skill, "Keep the plan true"). Record each decision that the owner or a review overturns as a Reversal: line in the ledger (process.reversals-are-recorded).
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

