@brainervirus/workit-cursor 8.22.3 → 8.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-cursor",
-  "version": "8.22.3",
+  "version": "8.24.0",
   "private": false,
   "description": "Workit Cursor plugin — shared MCP transport, native hooks, and sixteen method skills",
   "keywords": [
@@ -46,8 +46,8 @@
     "build": "bun scripts/build.ts"
   },
   "devDependencies": {
-    "@brainervirus/workit-core": "^8.22.3",
-    "@brainervirus/workit-mcp": "^8.22.3"
+    "@brainervirus/workit-core": "^8.24.0",
+    "@brainervirus/workit-mcp": "^8.24.0"
   },
   "engines": {
     "node": ">=24"

package/skills/workit-fanout/SKILL.md

@@ -20,14 +20,14 @@ units of ~100+ lines each. Coupled work stays with one owner. Workit never spawn
    PR (`references/orchestration.md`).
 2. **Record standing orders** (`workit ledger standing add "<order>"`): every
    user directive all workers share. Directives decay across resumes.
-3. **Brief each worker verbatim** with `workit fanout brief <slice>`: plan
-   fields, standing orders, SCRATCH, session id, fan-in and heavy-lease rules.
+3. **Brief each worker verbatim**: `workit fanout worktree create <slice>`
+   (every host), then `workit fanout brief <slice>` (WORKTREE, SCRATCH, rules).
    Never hand-edit it; change the plan or the standing orders and render again.
 4. **Spawn in a rolling window**, in the background, each in its own worktree:
    keep 4-6 in flight and refill from `spawnable` in `workit fanout status` as
    each one finishes. Model: the brief's `model:` line, else TIER
-   (`references/orchestration.md`). Claude Code: the `implementer` agent;
-   elsewhere first `workit fanout worktree create <slice>`.
+   (`references/orchestration.md`). Claude Code: the `implementer` agent, never
+   with `isolation: "worktree"`; Workit's hooks confine it to its WORKTREE.
 5. **Judge liveness by side effects only:** `workit fanout status` (head age,
    PR, CI, verdict, landed; STUCK past the TIMEBOX). Stop a stuck worker and
    observe that it exited (a timeout is not proof). Removing a worktree drops
@@ -40,7 +40,7 @@ units of ~100+ lines each. Coupled work stays with one owner. Workit never spawn
    chain resumes. A fix round and recheck that both fail: a decider, not a
    third round; product choices go to the user (`references/orchestration.md`).
 7. **Verify by the workspace `verification` setting** (`workit grant show`).
-   A report is a pointer, never evidence. `self`: a verifier that wrote none
+   A report is a pointer, never evidence. `proportional` (default): each slice's lane (`workit pr status`) decides; none needs no verdict, self the author's `--self`, focused (cheap model: Claude Code `model: sonnet`) and full a verifier after the last push. `self`: a verifier that wrote none
    of the slices, or you if you wrote none. `independent` or high risk: a
    separate verifier session, never yours (doctrine: the ledger only refuses
    authors). One verifier may take a batch of slices, one verdict per branch

package/skills/workit-fanout/references/brief.md

@@ -25,6 +25,7 @@ REPORT: branch, head SHA, files changed, each VERIFY command with its exit code,
   each ACCEPTANCE line met / not met, rulings you made (`workit ledger ruling`),
   anything out of scope as a follow-up, not a diff.
 STANDING: <the standing orders, verbatim: `workit ledger standing add` records each one>
+WORKTREE: <the path `workit fanout worktree create <slice>` made; the worker runs `workit --cwd <it> …` there>
   <identity line, per the lead's host: see "Identity and git rules per host" below>
 ```
 
@@ -48,6 +49,7 @@ FORBIDDEN: no edits outside SCOPE; no schema migration; no new packages
 FAN-IN: one PR per slice. Never rebase, retarget, merge or force-push: the lead owns topology.
 REPORT: as in the template
 STANDING: conventional commits; no comments that restate code; ask nothing, record rulings instead
+WORKTREE: ../app-wt/usage-endpoint  (made by `workit fanout worktree create usage-endpoint`; yours alone)
 ```
 
 ## Plan file
@@ -106,25 +108,29 @@ lead's host (`WORKIT_HOST`, or the host's own session variable):
 
 | Lead's host | Identity line | RULES 1 and 3 |
 | --- | --- | --- |
-| Claude Code | `Session: your env already has WORKIT_SESSION_ID (the lead's id)`; no `export`, no hand-minted id (SubagentStart issues `<lead>:<agent id>` only to verifiers and reviewers, never to an implementer, so the worker's commits carry the lead's id) | plain git: `git fetch origin && git switch -c <branch> origin/<base>` and `git commit -m <msg> --trailer "Workit-Session: <the env WORKIT_SESSION_ID>" --trailer "<host attribution>" -- <paths in SCOPE>`, because worktree isolation refuses every `workit git` form |
+| Claude Code | `Session: your env already has WORKIT_SESSION_ID (the lead's id)`; no `export`, no hand-minted id (SubagentStart issues `<lead>:<agent id>` only to verifiers and reviewers, never to an implementer, so the worker's commits carry the lead's id) | `workit git branch <branch> --base <base>`, `workit git commit -m <msg> -- <paths in SCOPE>`: the implementer runs without Claude Code's worktree isolation, which refused every `workit git` form |
 | OpenCode, Pi, Codex | `Session: your host already sets WORKIT_SESSION_ID in your shell`; export nothing (the host derives the id and an export cannot replace it) | `workit git branch <branch> --base <base>`, `workit git commit -m <msg> -- <paths in SCOPE>` |
 | Cursor, CI, a plain terminal | `export WORKIT_SESSION_ID=<lead>-w-<slice>` (`+try<n>` for a race attempt): declared, not checked | the same `workit git` forms |
 
-`MODE: resume` is `git switch <branch>` on every host (the branch exists; the
-lead removed the dead worker's worktree after its exit, so the switch
-succeeds), then continue from its head. A race attempt (`--attempt <n>`)
-follows its host's row with the branch `<branch>-try<n>`.
+Once `workit fanout worktree create <slice>` made the worktree, the brief's
+WORKTREE line names it and RULES 1 and 3 run against it on every host:
+`workit --cwd <worktree> git commit …`, `workit --cwd <worktree> check <name>`,
+one verb per call. The worktree is already on the branch (MODE new or resume),
+so no branch command comes first. Without one, `MODE: resume` is
+`git switch <branch>` (the branch exists), then continue from its head. A race
+attempt (`--attempt <n>`) follows its host's row with the branch
+`<branch>-try<n>`.
 
 ## Worker rules (`workit fanout brief` appends them as RULES)
 
-1. First command: create the branch (`MODE: new`; the worktree may start on a
-   name that breaks branch policy) or `git switch` to it (`MODE: resume`),
-   as the table above says for your host.
+1. Work only in WORKTREE, already on the branch, one verb per call against it
+   (`workit --cwd <worktree> …`); Workit's hooks deny an implementer's change
+   outside it. With no worktree made yet: create the branch (`MODE: new`) or
+   `git switch` to it (`MODE: resume`), as the table above says.
 2. Decide ambiguities yourself and record them:
    `workit ledger ruling "<what>" --why "<why>" --cost-if-wrong "<cost>"`.
    Stop only for an irreversible action, a security-sensitive one, or a side
    effect outside the worktree.
-3. Commit as the table says (`workit git commit -m "<msg>" -- <paths in SCOPE>`,
-   or plain git with the trailers on Claude Code); push only if the brief says
-   so.
+3. Commit with `workit --cwd <worktree> git commit -m "<msg>" -- <paths in SCOPE>`;
+   push only if the brief says so.
 4. Never record a verdict on your own work.

package/skills/workit-fanout/references/orchestration.md

@@ -35,8 +35,8 @@ parent is verified, appears there by itself.
 
 A slice is retried when it is STUCK, its worker exits without meeting
 ACCEPTANCE, or its verdict fails. Stop the worker and observe that it exited.
-Release its worktree: `workit fanout worktree release <slice>` (native
-worktrees: record `git -C <wt> status --short` first). Then spawn one fresh
+Release its worktree: `workit fanout worktree release <slice>` (it records
+`git status` first), and create it again for the retry. Then spawn one fresh
 worker with `workit fanout brief <slice> --mode resume`: same branch, and the
 brief points at its head and its ledger rows (last report, verdicts,
 rulings). If the retry fails too, escalate instead of a third worker:
@@ -69,9 +69,9 @@ list. The fixer applies that list once, then one focused recheck follows.
 When a hard slice has an uncertain approach and a cheap VERIFY, run 2-3
 attempts at once instead of retrying in series. `workit fanout brief <slice>
 --attempt <n>` gives each attempt its own branch (`<branch>-try<n>`), session
-and scratch dir. Each attempt needs its own worktree: Claude Code's
-`implementer` isolates natively; on other hosts `fanout worktree create` makes
-only the slice's own worktree, so run the attempts one after another there.
+and scratch dir. Each attempt needs its own worktree, and `fanout worktree
+create` makes only the slice's own one, so run the attempts one after another
+there on every host.
 Verify every attempt, keep the one with the best verdict (accepted first,
 then the fewest changed files, then the earliest), point the slice branch at
 it (`git branch <branch> <winner>`), have the verifier record the verdict on
@@ -109,7 +109,7 @@ Which session id a verdict carries, per host:
   `WORKIT_SESSION_ID=<lead>:verifier-<random hex>`, a fresh suffix per
   verifier. Cursor cannot check it: it is declared, not derived.
 - A worker's commits: on Claude Code the lead's `WORKIT_SESSION_ID` already in
-  its env (SubagentStart issues no implementer id; plain git, no export, so the
+  its env (SubagentStart issues no implementer id; no export, so the
   lead authored those commits: a verifier or reviewer records the verdict, not
   the lead); on OpenCode, Pi and Codex the id the host already
   puts in its shell; on Cursor, CI and a plain terminal the brief's

package/skills/workit-implement/SKILL.md

@@ -36,17 +36,19 @@ description: Build a requested change in small verified steps - follow local pat
    when that was requested, or the request implies delivery and the effective
    endpoint in `workit grant show` is `pr`, `green` or `merged`; `green` and
    `merged` keep babysitting. Otherwise it is `commit`.
-7. Verify, as far as the policy asks. Normal risk: after `workit check test`
-   passes, record your own `workit ledger verdict tests-verified --self --how
-   "<what you ran>"`; it reads self-reviewed, never verified, and is enough.
-   Ask a non-author only for high risk, a workspace with `verification:
-   independent` (`workit grant show`) or a verified merge: a fresh verifier with its own host-derived session (Claude Code and Codex:
+7. Verify as far as the review lane asks (`workit policy assess`, `workit pr
+   status`). Lane none: no verdict. Lane self: after `workit check test` passes,
+   record `workit ledger verdict tests-verified --self --how "<what you ran>"`;
+   it reads self-reviewed, never verified, and is enough. Focused, full, high
+   risk or `verification: self|independent` merges: one fresh verifier per PR after the last push, its own host-derived session (Claude Code: the `verifier` agent, `model: sonnet` when focused; Codex:
    the `verifier` agent; OpenCode: a child session; Pi: a supervised worker),
    never a hand-minted id. Before saying done, reconcile
    every named deliverable against the target checkout and observe it (for a push:
    `workit verify-delivery push`).
 
 Independent slices that could run in parallel: fan them out (read the `workit-fanout` skill's SKILL.md and follow it).
+One `implementer` slice: `workit fanout worktree create <slice>` before spawning,
+then `workit fanout brief <slice>`; no host isolation (Workit's hooks confine it).
 
 Stay inline by default (workspace `delegation: inline-first`). Hand work off
 only past the thresholds: an explorer after about 3 tool calls or 10k tokens

package/skills/workit-review/SKILL.md

@@ -13,6 +13,9 @@ OpenCode, a child session; Pi, a supervised worker. Never hand-mint one such
 as `<lead>-v1`: it is refused as `forged_session`.
 An author's `--self` verdict reads self-reviewed and never counts as
 independent; `type-check-only` never proves a behavior change.
+Depth follows the review lane in `workit pr status`: focused reads the diff and
+runs its tests; full also drives the real surface (verify-<app>). Review once
+per PR after its last push; a second pass on an unchanged head is waste.
 
 1. Pin the candidate: `git rev-parse HEAD`, the base, `git diff <base>...HEAD`;
    for a PR, `workit pr status --json` (checks, unresolved threads).

package/skills/workit-ship/SKILL.md

@@ -51,8 +51,7 @@ the same check. Fix round and recheck both failed: a decider (read the `workit-f
    allows; no sleep loop. Red: read `logTail`, classify. Flake or infra: one
    `workit ci rerun --failed --reason flake|infra` per head. Real: reproduce
    with `workit check`, fix the root cause, batch every fix in one push.
-6. **Verified.** High risk, `verification: independent` or a verified merge: a
-   non-author verdict (read the `workit-review` skill's SKILL.md and follow it); else a self verdict stands. Land only when
+6. **Verified.** The lane in `workit pr status` decides: none, no verdict; self, your `--self` verdict; focused or full (or `verification: self|independent`), one non-author verifier per PR after the last push, never per push (read the `workit-review` skill's SKILL.md and follow it), on Claude Code `model: sonnet` when focused. Land only when
    granted: `workit stack land` or `workit pr merge`; `--unverified --reason` if user-asked.
 7. **Observe it landed:** `workit verify-delivery pr` or `merge`. After a failed
    verdict or a check red 3+ times, at any endpoint: offer `/wk-retro` in one