@brainervirus/workit-cursor 8.24.0 → 8.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-cursor",
-  "version": "8.24.0",
+  "version": "8.26.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.24.0",
-    "@brainervirus/workit-mcp": "^8.24.0"
+    "@brainervirus/workit-core": "^8.26.0",
+    "@brainervirus/workit-mcp": "^8.26.0"
   },
   "engines": {
     "node": ">=24"

package/skills/workit-fanout/SKILL.md

@@ -25,8 +25,8 @@ units of ~100+ lines each. Coupled work stays with one owner. Workit never spawn
    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, never
+   each one finishes. Model: the brief's `model:` and `effort:` lines (`workit models show`),
+   else TIER (`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
@@ -40,12 +40,12 @@ 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. `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
+   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 and full a verifier (Claude Code: the `model` and `effort` of `workit models show --role verifier`) after the last push; one verdict at a stack's top covers its unchanged lower PRs, and a stale one with `reverify: focused` re-checks only the new diff, reusing green CI. `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
    (`workit ledger verdict <result> --branch <b> --how "<evidence>"`), in a
-   session never chosen by the author. A review panel on separate models only at high risk.
+   session never chosen by the author. Spawn it with the brief's `verifier:` model (`workit models show --role verifier`). A review panel on separate models only at high risk.
 8. **Fan in** with `workit fanout check`: out-of-scope files (any file outside
    it stops the fan-in) and `git merge-tree` conflicts with trunk and between
    siblings. Fix what it names until it exits 0; a merged slice reads as

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

@@ -25,7 +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>
+WORKTREE: <the path `workit fanout worktree create <slice>` made; the worker runs `workit <verb> --cwd <it> …` there>
   <identity line, per the lead's host: see "Identity and git rules per host" below>
 ```
 
@@ -114,7 +114,7 @@ lead's host (`WORKIT_HOST`, or the host's own session variable):
 
 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>`,
+`workit git --cwd <worktree> commit …`, `workit check --cwd <worktree> <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
@@ -124,13 +124,13 @@ attempt (`--attempt <n>`) follows its host's row with the branch
 ## Worker rules (`workit fanout brief` appends them as RULES)
 
 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
+   (`workit <verb> --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 with `workit --cwd <worktree> git commit -m "<msg>" -- <paths in SCOPE>`;
+3. Commit with `workit git --cwd <worktree> 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

@@ -5,22 +5,31 @@ and fans in. Workit records and checks; the host's own subagents run the work.
 
 ## TIER to model
 
-TIER is a field of each slice and of its brief. When the workspace sets
-`fanout.tierModels`, the brief has a `model:` line under TIER and `workit
-fanout status` names the model next to each spawnable slice: use that model.
-Without one, map TIER where the host lets you pick a model per spawn:
-
-| TIER | Claude Code (`model` on the Agent call) | Hosts without a per-spawn model |
-| --- | --- | --- |
-| scouting (read-only search, not a slice) | `haiku` | host default |
-| mundane | `sonnet` | host default |
-| standard | omit it (inherits yours) | host default |
-| hard | omit it (inherits yours); consider a race | host default |
-
-OpenCode takes a subagent's model from its agent config: pick a configured
-agent whose model fits the TIER, else the default. Codex, Cursor and Pi run
-every worker on the host's model, so TIER only sizes the timebox and decides
-whether to race.
+TIER is a field of each slice and of its brief. Role models come from the
+workspace (`models.roles`; `fanout.tierModels` still feeds the implementer
+tiers) and, on Claude Code, built-in defaults: the brief has a `model:` line
+(with `effort:` when set) under TIER and a `verifier:` line; `workit fanout
+status` names the model next to each spawnable slice; `workit models show
+[--role r] [--host h] --json` lists every role (decider, implementer tiers,
+verifier, reviewer, explore, babysit). Pass exactly that `model` (and `effort`
+where the host's spawn call takes one) on the spawn call: a subagent that
+passes none inherits your model. Scouting and PR babysitting use the `explore`
+and `babysit` roles. A role with no model (other hosts without config) runs
+on the host's model, and TIER only sizes the timebox and decides whether to
+race. Claude Code's built-in defaults, when nothing is configured:
+
+| Role or TIER | `model` on the Agent call |
+| --- | --- |
+| decider | `fable`, effort `high` |
+| hard | `opus` |
+| standard | `sonnet` |
+| mundane | `haiku` |
+| verifier | `sonnet` |
+| reviewer | `opus` |
+| explore, babysit | `haiku` |
+
+OpenCode takes a subagent's model from its agent config: pick a
+configured agent whose model fits the TIER, else the default.
 
 ## Rolling window
 
@@ -53,7 +62,7 @@ reversibility (the option cheapest to undo wins a tie), and the exact change
 list. The fixer applies that list once, then one focused recheck follows.
 
 - Hard call (shared contract, security, migration): two deciders on different
-  models (Claude Code: a different `model` on the Agent call; OpenCode: a
+  models (Claude Code: the `decider` role model, the other a different `model` on the Agent call; OpenCode: a
   child session on another configured agent; Codex, Cursor and Pi: one
   decider, since the host picks no model). If they disagree, you take the
   more reversible option.

package/skills/workit-implement/SKILL.md

@@ -40,7 +40,7 @@ description: Build a requested change in small verified steps - follow local pat
    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:
+   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 with the `model` (and `effort`) of `workit models show --role verifier`; 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:

package/skills/workit-review/SKILL.md

@@ -9,13 +9,16 @@ Review the candidate, never the author's summary of it. A session that wrote a
 commit on the branch cannot record a passing verdict: if that is you, hand the
 review to a fresh agent with its own host-derived session: Claude Code and
 Codex, the `reviewer` or `verifier` agent (`--session` and `--token` from SubagentStart);
-OpenCode, a child session; Pi, a supervised worker. Never hand-mint one such
+OpenCode, a child session; Pi, a supervised worker. On Claude Code pass the
+`model` and `effort` of `workit models show --role <verifier|reviewer>`. 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.
+A stale verdict showing `reverify: focused (<files>)` in `workit pr status`: re-check only
+those files since the judged head and reuse green CI there (no fresh install, no full suite).
 
 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,7 +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.** 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
+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 with the `model` and `effort` of `workit models show --role verifier`. A docs-only push (or test-only under a unit verdict) keeps the verdict (`carried`); `reverify: focused` re-checks only the new diff, reusing green CI; one verdict at a stack's top covers its unchanged lower PRs. 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