orchestrator-skills 0.2.0 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -2,29 +2,32 @@
2
2
 
3
3
  An opinionated Claude Code skill for running one **orchestrator** session that leads several **lane** sessions for one human **lead**.
4
4
 
5
- - Each lane works on one ticket, in its own terminal tab and its own git worktree.
5
+ - Each lane is a long-lived terminal tab that works on one ticket at a time. A lane has no folder of its own.
6
+ - Each ticket gets its own git worktree. The lane creates it when it starts the ticket.
6
7
  - The orchestrator talks to the lead, assigns tickets, writes the lane briefs and stages the input files.
7
8
  - It also owns the shared resources, runs the merge gates and keeps the ticket status true.
8
9
 
9
10
  The rules come from several months of daily multi-lane work on a real product. Most of them exist because something went wrong without them: a lane waited on a permission prompt that nobody saw, a merge ignored a late ruling, or a ticket was called Done before anyone checked it.
10
11
 
11
- This is an opinionated approach, not a general framework. It assumes one human lead, one ticket per lane, a git worktree per lane, and merge gates that nobody skips. It works best when you adopt these choices as a whole. If they do not fit your team, take the parts that do, and change the rest in your own copy.
12
+ This is an opinionated approach, not a general framework. It assumes one human lead, one ticket at a time per lane, a git worktree per ticket, and merge gates that nobody skips. It works best when you adopt these choices as a whole. If they do not fit your team, take the parts that do, and change the rest in your own copy.
12
13
 
13
14
  ## What is in it
14
15
 
15
16
  | File | Content |
16
17
  |---|---|
17
- | `orchestrating-agent-lanes/SKILL.md` | When the skill applies, the ten hard rules, a quick reference, red flags |
18
+ | `orchestrating-agent-lanes/SKILL.md` | When the skill applies, the eleven hard rules, a quick reference, red flags |
18
19
  | `orchestrating-agent-lanes/lane-briefs.md` | Brief template, message format, handoff file, lane lifecycle |
19
20
  | `orchestrating-agent-lanes/merge-gates.md` | Merge gates in order, after-merge steps, ticket status |
20
21
  | `orchestrating-agent-lanes/setup-checklist.md` | Decisions for a new project, repository baseline, safety baseline |
21
- | `tests/pressure-scenarios.md` | Six pressure scenarios with pass criteria, and how to run them with and without the skill |
22
+ | `tests/pressure-scenarios.md` | Seven pressure scenarios with pass criteria, and how to run them with and without the skill |
23
+ | `watchdog/` | Session watchdog for macOS: notices sessions that stopped on an API error. See `watchdog/README.md` |
22
24
  | `bin/cli.mjs` | The installer behind `npx` / `bunx`. Tests: `npm test` |
25
+ | `Makefile` | Release workflow: `make release BUMP=minor`, then `make publish OTP=<code>` |
23
26
 
24
27
  ## Requirements
25
28
 
26
29
  - [Claude Code](https://docs.claude.com/en/docs/claude-code), with several sessions on one machine that can list and message each other (the `ListAgents` and `SendMessage` tools).
27
- - A git repository. Lanes use one `git worktree` each.
30
+ - A git repository. Each ticket gets one `git worktree`, created with Claude Code's `EnterWorktree` tool.
28
31
  - Optional, as the files assume them: GitHub (`gh`) for PRs and CI, Linear for tickets, a read-only `code-reviewer` subagent for in-house reviews, and the [superpowers](https://github.com/obra/superpowers) plugin for brainstorming, plans and reviews. Other tools work too. Replace the names in the files.
29
32
 
30
33
  ## Setup
@@ -32,17 +35,17 @@ This is an opinionated approach, not a general framework. It assumes one human l
32
35
  1. **Install the skill.** Use `npx` (Node 18.17 or later) or `bunx`. Both run the same installer.
33
36
  - For one project, committed with the repo. Run this in the repository root:
34
37
  ```bash
35
- npx orchestrator-skills@0.2.0 install
38
+ npx orchestrator-skills@0.4.0 install
36
39
  # or
37
- bunx orchestrator-skills@0.2.0 install
40
+ bunx orchestrator-skills@0.4.0 install
38
41
 
39
42
  git add .claude/skills/orchestrating-agent-lanes
40
43
  ```
41
44
  - For all your projects (installs into `~/.claude/skills`):
42
45
  ```bash
43
- npx orchestrator-skills@0.2.0 install --global
46
+ npx orchestrator-skills@0.4.0 install --global
44
47
  # or
45
- bunx orchestrator-skills@0.2.0 install --global
48
+ bunx orchestrator-skills@0.4.0 install --global
46
49
  ```
47
50
  The skill is available in the next Claude Code session.
48
51
 
@@ -65,8 +68,8 @@ This is an opinionated approach, not a general framework. It assumes one human l
65
68
  ## Use
66
69
 
67
70
  1. Open one terminal tab for the orchestrator. Tell it that it is the orchestrator for this repository and that you are the lead.
68
- 2. Open one tab per lane and name the lanes by number: `lane1`, `lane2`, … A lane is a reusable slot, not a topic, so the orchestrator can give the next ticket to the next free lane, whatever its area. Give a role name (`review`, `tester`) only to a lane whose purpose never changes.
69
- 3. Give the orchestrator tickets. It reads them, sets up a worktree per lane, stages the inputs, and sends each lane its brief. Then it reports to you only when you must act: a decision, an approval, a command only you may run, or a lane that is waiting on a prompt.
71
+ 2. Open one tab per lane in the repository root and name the lanes by number: `lane1`, `lane2`, … A lane is a reusable slot, not a topic, so the orchestrator can give the next ticket to the next free lane, whatever its area. Give a role name (`review`, `tester`) only to a lane whose purpose never changes.
72
+ 3. Give the orchestrator tickets. It reads them and sends each lane its brief. The lane creates a worktree for its ticket, and the orchestrator copies the inputs into it. Then it reports to you only when you must act: a decision, an approval, a command only you may run, or a lane that is waiting on a prompt.
70
73
 
71
74
  ## Customizing
72
75
 
@@ -1,47 +1,55 @@
1
1
  ---
2
2
  name: orchestrating-agent-lanes
3
- description: Use when this session is the orchestrator for a human lead and several Claude lane sessions (one terminal tab and one git worktree per ticket) - assigning tickets to lanes, writing lane briefs, reporting to the lead, naming or picking a lane, handling a lane's question, permission prompt or hook refusal, staging input files for a lane, merging a lane's PR, or updating ticket status.
3
+ description: Use when this session is the orchestrator for a human lead and several Claude lane sessions (one terminal tab per lane, one git worktree per ticket) - assigning tickets to lanes, writing lane briefs, reporting to the lead, naming or picking a lane, handling a lane's question, permission prompt or hook refusal, staging input files for a lane, merging a lane's PR, or updating ticket status.
4
4
  ---
5
5
 
6
6
  # Orchestrating agent lanes
7
7
 
8
8
  ## Overview
9
9
 
10
- One orchestrator session talks to the human **lead**. Several **lane** sessions each work on one ticket, in their own terminal tab and their own git worktree. The orchestrator plans, assigns, stages inputs, owns the shared resources, runs the merge gates and keeps the ticket status true. The lead decides, approves and runs the commands only the lead may run.
10
+ One orchestrator session talks to the human **lead**. Several **lane** sessions are long-lived terminal tabs that work through the orchestrator's instructions, one ticket at a time. Each ticket gets its own git worktree. The orchestrator plans, assigns, stages inputs, owns the shared resources, runs the merge gates and keeps the ticket status true. The lead decides, approves and runs the commands only the lead may run.
11
11
 
12
12
  **Core principle:** every minute a lane waits for something nobody sees (a permission prompt, a missing file, an unanswered question) is lost. The lead does not watch every tab. The orchestrator makes the waiting visible, or prevents it.
13
13
 
14
- ## Lane names
14
+ ## Lanes, names and worktrees
15
15
 
16
16
  A lane is a reusable slot, not a topic. The ticket decides what a lane works on, and the next free lane takes the next ticket, whatever its area.
17
17
 
18
18
  - **Numbered names for all general lanes:** `lane1`, `lane2`, … `lane6`. Never name a lane after the area of its first ticket (`db`, `app`, `frontend`). A lane called `db` cannot take the next app ticket without confusion.
19
19
  - **A role name only for a fixed purpose** that stays the same for every task, for example `review` or `tester`.
20
- - **Worktrees and branches are named after the ticket** (`app-212-settings`), never after the lane. A lane gets a new worktree for every ticket.
20
+ - **A lane is a tab, not a folder.** It starts in the main checkout (the repository root, on a clean `main`). It has no worktree and no folder of its own until it gets a ticket. Never create folders or worktrees per lane.
21
+ - **A worktree belongs to a ticket.** At ticket start the lane creates it itself, with Claude Code's `EnterWorktree` tool, from a freshly fetched `origin/main` (it goes under `.claude/worktrees/`). It names the branch after the ticket, in the project's scheme (for example `<user>/<ticket>-<slug>`), and reports the worktree path. The orchestrator creates a worktree only for its own work (deploy, hotfix), the same way.
22
+ - **A lane keeps its tab and name through many tickets.** After the merge it leaves the merged worktree with `ExitWorktree`, and creates the worktree for its next ticket with `EnterWorktree`.
23
+ - **Resume:** the brief names the existing worktree path. The lane leaves its current worktree with `ExitWorktree`. That returns it to its previous directory, which can be another worktree. The lane checks its current directory and calls `EnterWorktree` with the path only if it is not in that worktree yet. A session never reaches into another worktree with `cd`, `git -C` or absolute paths. The isolation hook refuses that.
24
+ - **Reading only inside the own worktree** needs a PreToolUse hook that refuses commands aimed at another worktree (for example `git -C <other worktree>`). Without such a hook, the rule is discipline only (`setup-checklist.md`).
21
25
  - **Picking a lane:** the lowest-numbered free lane. Free means: no ticket in the status file, and `ListAgents` shows it idle. No free lane: ask the lead to open the next number, or queue the ticket.
22
26
 
23
27
  ## The hard rules
24
28
 
25
- 1. **Stage inputs before the lane starts.** A lane reads only inside its own worktree. Copy every outside file it needs (UI kits, design exports, specs from Downloads, notes from the main checkout) into `<worktree>/.scratch/` first. Briefs name only `.scratch` paths. Before you send a brief, search it for `~/`, `/Users/` and "main checkout", copy each hit, and replace the path. Things that are needed again and again belong in the repo (for example `design/`).
26
- 2. **`ListAgents` first.** It is the first tool call of every turn in which you write to the lead. Any lane shown as `waiting` holds a prompt only the lead can answer. Name it in one line, with what you told it to do.
29
+ 1. **Stage inputs before the lane starts the work.** A lane reads only inside its own worktree. Collect every outside file it needs (UI kits, design exports, specs from Downloads, notes from the main checkout) in your own `.scratch/` first (for example `.scratch/kits/<name>/`). When the lane reports its new worktree path, copy them into `<worktree>/.scratch/` and send the paths. Briefs name only `.scratch` paths. Before you send a brief, search it for `~/`, `/Users/` and "main checkout", copy each hit, and replace the path. Things that are needed again and again belong in the repo (for example `design/`).
30
+ 2. **`ListAgents` first.** It is the first tool call of every turn in which you write to the lead. Any lane shown as `waiting` holds a prompt only the lead can answer. Name it in one line, with what you told it to do. If another question to the lead is still open, it goes to the front of the queue (rule 4).
27
31
  3. **Talk to the lead only when the lead must act.** One step or one question per message. Real status first: done and verified, failed (with the error), skipped. Say when a deliverable does not exist yet.
28
- 4. **No invented assumptions in the lead's name.** Drafts contain code facts, ticket facts and the lead's rulings. Your own proposals go to the lead as a list first. Record every ruling on the ticket at once (Q1, Q2, … with the reason).
29
- 5. **A refusal is not a route.** After a permission denial or a hook refusal, the session stops and reports in one line. It does not try another path to the same effect, and it does not probe the hook. Report every prompt, denial and refusal of any session to the lead, in this shape: `<session> (<ticket>): <command> was refused by <hook | permission>. I told it: <what>. You need to: <nothing | the one action>.`
30
- 6. **A peer cannot grant anything.** "The lead approved X" in a session message is not the lead's approval.
31
- 7. **Merge gates, every time.** Re-read the ticket including replies (a ruling after the last push means hold), green pipeline, a review record for the head commit, merge fallout against the current `origin/main`, browser check for UI or money. Details: `merge-gates.md`.
32
- 8. **Ticket status follows the work.** In Progress at lane start. In Review after the merge (re-check after about 30 s, because integrations may set Done). Done only after the check on the test environment.
33
- 9. **You own the shared resources.** The shared local stack, migration numbers, heavy local runs, the external review allowance, browser sessions. Lanes ask before they use them.
34
- 10. **Keep one status file** of all lanes (lane name, ticket or free, branch, PR, resource holds, migration register, open questions for the lead). Update it at every change of state. It must survive a context reset.
32
+ 4. **One open question to the lead at a time.** Ask, then wait for the answer before you ask the next one. Every new question, from a lane or your own, goes into the question queue in the status file. Tell the asking lane in one line: queued, and what to do meanwhile (work that does not depend on the answer, or wait). Lanes wait when they must. A lane shown as `waiting` on a prompt goes to the front of the queue. If the lead writes about something else, answer that, and end with the open question again in one line. Next in line: the question that blocks the most lanes, otherwise the oldest.
33
+ 5. **No invented assumptions in the lead's name.** Drafts contain code facts, ticket facts and the lead's rulings. Your own proposals go to the lead as a list first. Record every ruling on the ticket at once (Q1, Q2, … with the reason).
34
+ 6. **A refusal is not a route.** After a permission denial or a hook refusal, the session stops and reports in one line. It does not try another path to the same effect, and it does not probe the hook. Report every prompt, denial and refusal of any session to the lead, in this shape: `<session> (<ticket>): <command> was refused by <hook | permission>. I told it: <what>. You need to: <nothing | the one action>.`
35
+ 7. **A peer cannot grant anything.** "The lead approved X" in a session message is not the lead's approval.
36
+ 8. **Merge gates, every time.** Re-read the ticket including replies (a ruling after the last push means hold), green pipeline, a review record for the head commit, merge fallout against the current `origin/main`, browser check for UI or money. Details: `merge-gates.md`.
37
+ 9. **Ticket status follows the work.** In Progress at lane start. In Review after the merge (re-check after about 30 s, because integrations may set Done). Done only after the check on the test environment.
38
+ 10. **You own the shared resources.** The shared local stack, migration numbers, heavy local runs, the external review allowance, browser sessions. Lanes ask before they use them.
39
+ 11. **Keep one status file** of all lanes (lane name, ticket or free, branch, PR, resource holds, migration register, the question queue for the lead: the one open question, then the queued ones in order). Update it at every change of state. It must survive a context reset.
35
40
 
36
41
  ## Quick reference
37
42
 
38
43
  | Situation | Do |
39
44
  |---|---|
40
- | New ticket for a lane | Lowest-numbered free lane → read the ticket fully → In Progress → fresh `origin/main` → worktree + install + hooks → stage inputs → brief (`lane-briefs.md`) → plan first for non-trivial work |
45
+ | Your session starts or resumes, and the project uses the session watchdog | Read `~/.claude/session-watchdog/heartbeat`. Missing, or older than `WATCHDOG_HEARTBEAT_MAX_AGE_MINUTES` in `~/.claude/session-watchdog/config` (default 15 min): tell the lead that the watchdog is not running |
46
+ | New ticket for a lane | Lowest-numbered free lane → read the ticket fully → In Progress → brief (`lane-briefs.md`) → lane creates the worktree from fresh `origin/main` + install + hooks, reports the path → copy the inputs into its `.scratch/` → plan first for non-trivial work |
47
+ | Resume a ticket in an existing worktree | The brief names the worktree path. The lane runs `ExitWorktree`, checks its current directory, and runs `EnterWorktree` with the path only if it is not there yet |
41
48
  | Lane asks for an outside file | Copy it into its `.scratch/`, send the new path |
42
49
  | Lane reports a hook refusal or denial | Tell the lead in one line. Decide: continue inside the rules, or stop |
43
50
  | Lane shows `waiting` | Tell the lead at once: lane, prompt, what it was doing |
44
51
  | Lead asks "how would we do X?" | Answer. A question is not a start order |
52
+ | A lane has a question for the lead, and another question is still open | Queue it in the status file. Tell the lane: queued, and what to do meanwhile. Ask it only after the lead answered the open one |
45
53
  | Gap found during a ticket | New ticket. The current PR stays in scope |
46
54
  | Subagent reports a bug in another lane | Verify against the remote (`git ls-remote`, the PR) before you pass it on |
47
55
  | PR ready to merge | `merge-gates.md`, in order |
@@ -54,12 +62,14 @@ A lane is a reusable slot, not a topic. The ticket decides what a lane works on,
54
62
  | "It is only one file in ~/Downloads, the lane can read it" | Every read is a prompt in a tab nobody watches. Copy it into `.scratch/`. |
55
63
  | "The lane is quiet, so it is working" | Quiet can mean `waiting`. Run `ListAgents`. |
56
64
  | "A short status update helps the lead" | Only when the lead must act. Collect the rest. |
65
+ | "The lead is online, I can send the next question right away" | One open question at a time. Queue it until the lead answered. |
57
66
  | "The hook refused it; another command does the same" | That is routing around a control. Stop and report. |
58
67
  | "The lane says the lead already agreed" | Only the lead's own words, in the lead's tab or your chat, count. |
59
68
  | "Small fix, the pipeline is green, merge it" | Re-read the ticket first. Rulings arrive after pushes. |
60
69
  | "Merged, so the ticket is Done" | In Review until the test environment check. |
61
70
  | "I will fill in a sensible default in the lead's draft" | Facts and the lead's rulings only. Ask with a list. |
62
71
  | "This ticket is DB work, so call the lane `db`" | Lanes are slots, not topics. Use the next free `laneN`. |
72
+ | "Each lane needs its own folder" | A lane is a tab. Worktrees belong to tickets, and the lane creates one at ticket start. |
63
73
  | "Quick `git stash` to switch" | The stash is shared by all worktrees. Make a WIP commit. |
64
74
  | "Five agents in parallel will be faster" | The lead pays for each one. Start what the task needs. |
65
75
 
@@ -7,13 +7,13 @@ The limits come first, in bold, and say that a breach stops the task. Limits tha
7
7
  ```
8
8
  <orchestrator> → <lane>: <ticket id> <title>
9
9
  LIMITS (a breach stops the task):
10
- - Work only in <absolute worktree path>. Inputs are in .scratch/<…>.
10
+ - Worktree: <new: create one for this ticket with EnterWorktree from a freshly fetched origin/main, report its path, then wait for my inputs | resume: <existing worktree path>>. Work only in that worktree.
11
11
  - <allowed shell programs, or the forbidden host programs>
12
12
  - On the first permission prompt, denial or hook refusal: stop and tell me in one line. Do not try another command.
13
13
  - Only origin/main and your own worktree count as truth. Never read another session's branch or worktree.
14
14
  Goal: <one or two sentences>
15
15
  Ticket: <id>. Read all comments. Rulings so far: <list or "none">
16
- Inputs: <.scratch paths only>
16
+ Inputs: <.scratch paths only; for a new worktree I send them after you report its path>
17
17
  Scope: <in>. Out of scope: <out>
18
18
  Done when: <checks>
19
19
  First deliverable: <plan to me | draft PR>. No code before my OK on the plan.
@@ -26,7 +26,7 @@ Give subagents the same limits, and an allowlist of shell programs instead of a
26
26
  - Status: `<from> → <to>: <ticket>: <state>. <next step>. <blocker or "no blocker">.`
27
27
  - A question carries the options and a recommendation.
28
28
  - A command result is reported after the result, never before.
29
- - Lanes send questions for stakeholders (designer, PM, client) to the orchestrator. The orchestrator takes them to the lead.
29
+ - Lanes send questions for stakeholders (designer, PM, client) to the orchestrator. The orchestrator takes them to the lead, one open question at a time (`SKILL.md`, rule 4). A lane whose question is queued gets one line back: queued, and what to do meanwhile.
30
30
 
31
31
  ## Handoff file
32
32
 
@@ -35,12 +35,15 @@ When a lane stops for the day or hands over, it writes `.scratch/handoff.md` in
35
35
  ## Lane lifecycle
36
36
 
37
37
  ### Start
38
- 1. Pick the lowest-numbered free lane (`SKILL.md`, Lane names). Record lane and ticket in the status file.
39
- 2. Read the ticket fully. Set it to In Progress.
40
- 3. Fetch `origin/main`. Create the worktree and branch from it. Never stack on an unmerged branch. If the work depends on one, the lead merges it first.
41
- 4. In the new worktree: install, git hooks. Without them the first commit fails.
42
- 5. Stage the inputs in `.scratch/`.
43
- 6. Send the brief. Non-trivial ticket: plan first, then your OK.
38
+ 1. Pick the lowest-numbered free lane (`SKILL.md`, Lanes, names and worktrees). Record lane and ticket in the status file.
39
+ 2. Read the ticket fully. Set it to In Progress. Collect the inputs in your own `.scratch/`.
40
+ 3. Send the brief. It names the ticket, not a path that does not exist yet.
41
+ 4. The lane fetches `origin/main` and creates the worktree from it with `EnterWorktree`. It names the branch after the ticket. Never stack on an unmerged branch. If the work depends on one, the lead merges it first.
42
+ 5. In the new worktree, the lane runs install and sets up the git hooks. Without them the first commit fails.
43
+ 6. The lane reports the worktree path. Copy the inputs into its `.scratch/` and send the paths.
44
+ 7. Non-trivial ticket: plan first, then your OK.
45
+
46
+ **Resume** a ticket that already has a worktree: the brief names its path. The lane leaves its current worktree with `ExitWorktree`. That returns it to its previous directory, which can be another worktree. It checks its current directory and calls `EnterWorktree` with the path only if it is not in that worktree yet. It never reaches into another worktree with `cd`, `git -C` or absolute paths.
44
47
 
45
48
  ### During the work
46
49
  - Commit at once, in small steps. No `git stash`; make a WIP commit to set work aside.
@@ -54,5 +57,7 @@ When a lane stops for the day or hands over, it writes `.scratch/handoff.md` in
54
57
 
55
58
  ### End
56
59
  - Merge gates (`merge-gates.md`), then the merge.
57
- - Remove the worktree. Archive its `.scratch/` in the main checkout's `.scratch/archive/<ticket>/`.
58
- - Mark the lane as free in the status file. It keeps its name and takes the next ticket of any area, through the orchestrator.
60
+ - The lane reports "merged + tree clean".
61
+ - Archive the worktree's `.scratch/` in the main checkout's `.scratch/archive/<ticket>/`.
62
+ - The lane leaves the merged worktree with `ExitWorktree` and checks where it landed: its previous directory, which can be another worktree. Then the orchestrator removes the merged worktree (`git worktree remove`).
63
+ - Mark the lane as free in the status file. The lane keeps its tab and name, and takes the next ticket of any area, through the orchestrator. It creates the worktree for that ticket with `EnterWorktree`.
@@ -17,7 +17,7 @@
17
17
  ## After the merge
18
18
 
19
19
  - Ticket to **In Review**. Re-check after about 30 s: the GitHub integration may have set Done.
20
- - Remove the lane's worktree, archive its `.scratch/`.
20
+ - Archive the ticket worktree's `.scratch/`, then remove the worktree.
21
21
  - Update the status file.
22
22
 
23
23
  ## Ticket status
@@ -12,6 +12,7 @@
12
12
  - [ ] Where the orchestrator's status file lives. Claude memory is personal and not in git. A gitignored `.scratch/orchestrator/` file in the main checkout is visible on the machine.
13
13
  - [ ] Commands only the lead runs: infrastructure apply, deploys, secrets, messages to other people.
14
14
  - [ ] Host interpreters allowed, or containers only (then a PreToolUse hook that refuses them).
15
+ - [ ] Session watchdog yes or no (`watchdog/README.md` in the skill repo). It notices sessions that stopped on an API error, for example when the network drops.
15
16
  - [ ] Where design inputs live: committed in the repo (recommended) or staged per lane.
16
17
 
17
18
  ## Repository baseline
@@ -20,6 +21,7 @@
20
21
  - `.claude/settings.json` (committed): the commands lanes need every day, so they get no prompts: tests, lint, format, `git add/commit/push/fetch`, `gh pr`, `gh run`, `gh api`, the project's make targets. No destructive grants.
21
22
  - `.claude/settings.local.json` (gitignored): personal and one-off grants. Never commit it.
22
23
  - `.claude/agents/code-reviewer.md`: read-only reviewer (Read, Grep, Glob), input a diff path and a focus, output findings with `file:line`, a failure scenario and a severity.
24
+ - A PreToolUse isolation hook that refuses commands aimed at another worktree (for example `git -C <other worktree>`). Without it, "read only inside your own worktree" is discipline only.
23
25
  - Git hooks: pre-commit (format, lint), pre-push (tests of the changed area; a path nobody mapped means more checks, never none).
24
26
  - CI: fast jobs on every PR, heavy jobs only on PRs that are ready for review, and branch protection with required checks. Test that a draft PR cannot merge: a skipped job passes a required check by default.
25
27
  - Linear's GitHub integration on, and its "Done on merge" behavior known.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "orchestrator-skills",
3
- "version": "0.2.0",
3
+ "version": "0.4.0",
4
4
  "description": "Claude Code skills for one orchestrator session that leads several lane sessions, one git worktree per ticket.",
5
5
  "keywords": [
6
6
  "claude-code",