@brainervirus/workit-core 8.24.0 → 8.26.0

package/src/core/workspaces.ts

@@ -166,6 +166,12 @@ const workspaceConfigSchema = z
      * name or per host family; read leniently (workspaceTierModel).
      */
     fanout: z.object({ tierModels: z.unknown().optional() }).passthrough().optional(),
+    /**
+     * Model and effort per role and host (`models.roles`, core/role-models.ts);
+     * read leniently there. The same key at the top of workspaces.json is the
+     * global default.
+     */
+    models: z.object({ roles: z.unknown().optional() }).passthrough().optional(),
     /** Autonomy grants (D15): only ever set here, by the user. */
     autonomy: z
       .object(
@@ -219,7 +225,10 @@ const workspaceConfigSchema = z
     }
   });
 const workspacesFileSchema = z
-  .object({ workspaces: z.array(workspaceConfigSchema).optional() })
+  .object({
+    workspaces: z.array(workspaceConfigSchema).optional(),
+    models: z.object({ roles: z.unknown().optional() }).passthrough().optional(),
+  })
   .passthrough()
   .superRefine((file, context) => {
     const names = new Set<string>();
@@ -788,7 +797,52 @@ export const workspaceDelegation = (cwd: string, dir?: string): DelegationMode =
   return isDelegation(source?.delegation) ? source.delegation : "inline-first";
 };
 
-const hostFamily = (host: string): string => host.replace(/_(?:cli|desktop)$/u, "");
+/**
+ * Where `models.roles` and `fanout.tierModels` can come from for cwd, nearest
+ * first: the selected workspace, each enclosing one (most specific first),
+ * then the global default at the top of workspaces.json. Read leniently: an
+ * unreadable file reads as no sources.
+ */
+export const modelSources = (
+  cwd: string,
+  dir?: string,
+): Array<{ name: string; global: boolean; models: unknown; tierModels: unknown }> => {
+  const out: Array<{ name: string; global: boolean; models: unknown; tierModels: unknown }> = [];
+  try {
+    const matched = matchRuntimeWorkspace(cwd, dir);
+    if (matched) {
+      const enclosing = matched.matches
+        .filter((entry) => entry !== matched.selected)
+        .toSorted((a, b) => globSpecificity(b.glob) - globSpecificity(a.glob));
+      for (const entry of [matched.selected, ...enclosing])
+        out.push({
+          name: entry.name,
+          global: false,
+          models: entry.models,
+          tierModels: (entry.fanout as { tierModels?: unknown } | undefined)?.tierModels,
+        });
+    }
+  } catch {
+    // An unreadable or invalid file: no workspace sources.
+  }
+  try {
+    const document: unknown = JSON.parse(
+      readFileSync(path.join(dir ?? configDir(), "workspaces.json"), "utf8"),
+    );
+    if (document && typeof document === "object" && !Array.isArray(document))
+      out.push({
+        name: "global",
+        global: true,
+        models: (document as Record<string, unknown>).models,
+        tierModels: undefined,
+      });
+  } catch {
+    // No global default.
+  }
+  return out;
+};
+
+export const hostFamily = (host: string): string => host.replace(/_(?:cli|desktop)$/u, "");
 
 const TIER_KEYS = new Set(["mundane", "standard", "hard"]);
 const TIER_HOSTS = new Set([
@@ -841,39 +895,6 @@ export const workspaceTierModelIssues = (cwd: string, dir?: string): string[] =>
   return issues;
 };
 
-/**
- * The model `fanout.tierModels` names for a tier on a host, or null (the
- * fanout skill's TIER guidance applies). A tier maps to one model name for
- * every host, or to `{ <host>: <model> }` keyed by host family (claude_code,
- * opencode, codex, cursor, pi) with an optional `default`. Inherited like
- * `trailers`, per tier; anything malformed reads as unset.
- */
-export const workspaceTierModel = (
-  cwd: string,
-  tier: string,
-  host: string | null,
-  dir?: string,
-): { model: string; workspace: string } | null => {
-  const pick = (entry: RuntimeEntry): string | null => {
-    const fanout = entry.fanout as { tierModels?: unknown } | undefined;
-    const models = fanout?.tierModels;
-    if (!models || typeof models !== "object" || !Object.hasOwn(models, tier)) return null;
-    const value = (models as Record<string, unknown>)[tier];
-    if (typeof value === "string") return value.trim() || null;
-    if (!value || typeof value !== "object") return null;
-    const byHost = value as Record<string, unknown>;
-    const family = host ? hostFamily(host) : null;
-    const named =
-      (family && Object.hasOwn(byHost, family) ? byHost[family] : undefined) ??
-      (host && Object.hasOwn(byHost, host) ? byHost[host] : undefined) ??
-      (Object.hasOwn(byHost, "default") ? byHost.default : undefined);
-    return typeof named === "string" && named.trim() ? named.trim() : null;
-  };
-  const found = inheritedSetting(cwd, dir, (entry) => pick(entry) !== null);
-  const model = found?.source ? pick(found.source) : null;
-  return model && found?.source ? { model, workspace: found.source.name } : null;
-};
-
 const resolveRuntimeWorkspaceCandidate = (
   cwd: string,
   kind: RuntimeWorkspacePolicy,

package/src/fanout-brief.ts

@@ -13,14 +13,14 @@
 // workers export nothing (the host derives the id);
 // Cursor, CI and plain terminals export `<lead>-w-<slice>`. Once
 // `workit fanout worktree create` made the slice's worktree, WORKTREE and the
-// RULES name it: every git and check command runs as `workit --cwd <worktree> …`.
+// RULES name it: every git and check command runs as `workit <verb> --cwd <worktree> …`.
 // The lead must have a WORKIT_SESSION_ID: worker ids derive from it. A
 // worker id longer than the ledger's 128 characters hashes its slice part. The fan-in line follows the plan's `fanIn`:
 // one PR per slice forbids every merge; integration mode has the worker merge
 // the integration tip before reporting, and nothing else. It only reads, apart
 // from hiding `.workit-scratch/` in the repository's info/exclude.
 import { createHash } from "node:crypto";
-import { workspaceTierModel } from "./core/workspaces";
+import { resolveRoleModel } from "./core/role-models";
 import { activeStanding, readLedger, type LedgerActor } from "./ledger";
 import { branchRef, fanoutFail, planLeads, type FanoutFile, type FanoutResult } from "./fanout";
 import {
@@ -44,8 +44,12 @@ export type BriefOutcome = {
   tier: string;
   /** Issues the slice's PR links (the brief's ISSUE line). */
   issues: string[];
-  /** The model `fanout.tierModels` names for the tier on the lead's host, else null. */
+  /** The model `models.roles` (or `fanout.tierModels`) names for the tier on the lead's host, else null. */
   model: string | null;
+  /** Its effort, when one is configured. */
+  effort: string | null;
+  /** The model and effort the lead spawns this slice's non-author verifier with, else null. */
+  verifier: { model: string; effort: string | null } | null;
   /** Absolute when the slice's worktree exists, else relative to the worker's worktree root. */
   scratch: string;
   /** The id a worker exports, or null when its host issues or derives it. */
@@ -96,8 +100,9 @@ const identityLines = (identity: BriefIdentity, session: string): string[] => {
 
 /**
  * RULES. With the slice's worktree made (`worktree`), every git and check
- * command names it (`workit --cwd <worktree> …`, one verb per call) and it is
- * already on the branch; Workit's hooks keep an implementer inside it (#310).
+ * command names it (`workit <verb> --cwd <worktree> …`, verb first so host
+ * allow rules match, one verb per call) and it is already on the branch;
+ * Workit's hooks keep an implementer inside it (#310).
  */
 const rules = (
   mode: BriefMode,
@@ -105,17 +110,18 @@ const rules = (
   base: string,
   worktree: string | null,
 ): string[] => {
-  const workit = worktree ? `workit --cwd ${worktree}` : "workit";
+  const workit = (verb: string) =>
+    worktree ? `workit ${verb} --cwd ${worktree}` : `workit ${verb}`;
   let first = `  1. First command: \`workit git branch ${branch} --base ${base}\` (your worktree may start on another name).`;
   if (worktree)
-    first = `  1. Work only in WORKTREE, already on ${branch}${mode === "resume" ? " at its head" : ""}: edit files under it and run each git and check command against it, one verb per call (\`${workit} git commit …\`, \`${workit} check <name>\`), never \`cd … &&\` chains or \`$VAR\` paths. An implementer's change outside it is denied.`;
+    first = `  1. Work only in WORKTREE, already on ${branch}${mode === "resume" ? " at its head" : ""}: edit files under it and run each git and check command against it, one verb per call (\`${workit("git")} commit …\`, \`${workit("check")} <name>\`), never \`cd … &&\` chains or \`$VAR\` paths. An implementer's change outside it is denied.`;
   else if (mode === "resume")
     first = `  1. First command: \`git switch ${branch}\`, then continue from its head.`;
   return [
     "RULES:",
     first,
     '  2. Decide ambiguities yourself: `workit ledger ruling "<what>" --why "<why>" --cost-if-wrong "<cost>"`; stop only for an irreversible, security-sensitive or out-of-worktree action.',
-    `  3. Commit with \`${workit} git commit -m <msg> -- <paths in SCOPE>\`; push only if this brief says so.`,
+    `  3. Commit with \`${workit("git")} commit -m <msg> -- <paths in SCOPE>\`; push only if this brief says so.`,
     "  4. Never record a verdict on your own work.",
     "  5. Run tests, lint, typecheck and builds only through `workit check` (a named check, or `workit check --heavy -- <cmd>`): one machine-wide lease queues every agent, so never a hand-made flock; `workit lock status` shows who holds it.",
     "  6. A failed review gets one fix round and one recheck. Still failing: stop and report the open finding, never a third round (the lead spawns a decider). A product choice is the user's: report it, do not decide it.",
@@ -183,7 +189,8 @@ export function renderBrief(
     what: String(row.what),
   }));
   const identity = identityOf(input.actor.host);
-  const model = workspaceTierModel(cwd, slice.tier, input.actor.host);
+  const model = resolveRoleModel(cwd, { role: "implementer", tier: slice.tier }, input.actor.host);
+  const verifier = resolveRoleModel(cwd, { role: "verifier" }, input.actor.host);
   const minted = workerSession(sessionSafe(input.actor.session), slice.id, input.attempt);
   const session = identity === "declared" ? minted : null;
   const fanIn =
@@ -220,7 +227,14 @@ export function renderBrief(
     ...(slice.reason ? [`REASON: ${slice.reason}`] : []),
     `TIER: ${slice.tier}`,
     ...(model
-      ? [`  model: ${model.model}  (fanout.tierModels in workspace ${model.workspace})`]
+      ? [
+          `  model: ${model.model}${model.effort ? `  effort: ${model.effort}` : ""}  (${model.source})`,
+        ]
+      : []),
+    ...(verifier
+      ? [
+          `  verifier: model ${verifier.model}${verifier.effort ? `  effort ${verifier.effort}` : ""}  (${verifier.source})`,
+        ]
       : []),
     `TIMEBOX: ${slice.timebox ?? DEFAULT_TIMEBOX}; past it without a new commit you will be replaced`,
     scratchLine,
@@ -249,6 +263,8 @@ export function renderBrief(
       tier: slice.tier,
       issues: slice.issues,
       model: model?.model ?? null,
+      effort: model?.effort ?? null,
+      verifier: verifier ? { model: verifier.model, effort: verifier.effort } : null,
       scratch,
       session,
       standing,

package/src/fanout-status.ts

@@ -18,7 +18,7 @@
 import { parseDuration } from "./duration";
 import { checksState, gatingChecks, missingRequired, type ChecksState } from "./forge/report";
 import type { ResolvedForge } from "./forge/resolve";
-import { workspaceTierModel } from "./core/workspaces";
+import { resolveRoleModel } from "./core/role-models";
 import { actorFromEnv, checkVerdicts, readLedger, type ReadRow, type VerdictBasis } from "./ledger";
 import { sliceLandings } from "./fanout-check";
 import { forgeBreaker, inSliceRun } from "./fanout-landed";
@@ -75,7 +75,7 @@ export type StatusOutcome = {
   landingOrder: string[];
   /** Not started; every dependency landed (or, stacked, its parent has an accepted verdict). */
   spawnable: string[];
-  /** The model `fanout.tierModels` names for each spawnable slice's TIER on this host. */
+  /** The model `models.roles` (or `fanout.tierModels`) names for each spawnable slice's TIER on this host. */
   spawnModels: Record<string, string>;
   stuck: string[];
   next: string;
@@ -288,7 +288,7 @@ export function fanoutStatus(
   const spawnModels: Record<string, string> = {};
   for (const id of spawnable) {
     const tier = plan.slices.find((slice) => slice.id === id)?.tier;
-    const model = tier ? workspaceTierModel(cwd, tier, host) : null;
+    const model = tier ? resolveRoleModel(cwd, { role: "implementer", tier }, host) : null;
     if (model) spawnModels[id] = model.model;
   }
   const spawnList = spawnable

package/src/fanout-worktree.ts

@@ -480,7 +480,7 @@ export function releaseSliceWorktree(
     return fanoutFail(
       "blocked",
       `this command runs inside ${entry.path}`,
-      `run it from the main checkout: workit --cwd <main checkout> fanout worktree release ${slice.id}`,
+      `run it from the main checkout: workit fanout --cwd <main checkout> worktree release ${slice.id}`,
     );
   if (entry.branch !== null && entry.branch !== `refs/heads/${slice.branch}`)
     return fanoutFail(

package/src/forge/pr-ops.ts

@@ -35,12 +35,13 @@ import { spawnSync } from "node:child_process";
 import { currentBranch, fetchRefs, GIT_TIMEOUTS, remoteRefTip, resolveRef } from "../git/rev";
 import {
   appendObserved,
-  checkVerdicts,
   tamperedUnblock,
   readLedger,
+  type CarryNote,
   type LedgerActor,
   type VerdictCheck,
 } from "../ledger";
+import { checkVerdictsCovered, type StackCover } from "../verdict-cover";
 import type { LaneNeed, ReviewLane } from "../core/policy/lane";
 import { laneLabel, prLaneGate } from "../core/policy/pr-lane";
 import { buildStatusDoc, selectPr, type PrStatusDoc } from "./report";
@@ -379,6 +380,10 @@ export type MergeOutcome = {
     lane: ReviewLane;
     need: LaneNeed;
     verification: VerificationMode;
+    /** The stack verdict above this PR that covers it (#334), when it has none of its own. */
+    cover?: StackCover | null;
+    /** How a verdict on an older head carried to this one over a follow-up change (#334). */
+    carry?: CarryNote | null;
   };
   /** Set when `--unverified` bypassed the verdict: the reason and its ledger row. */
   unverified: { reason: string; recorded: string } | null;
@@ -662,7 +667,8 @@ export async function mergePullRequest(
   }
   const ledger = readLedger(cwd, { integrity: true });
   if (!ledger.ok) return ledger;
-  const check = checkVerdicts(cwd, branch, ledger.value.rows);
+  // A lower PR of a stack may be covered by the verdict at its top (#334).
+  const check = checkVerdictsCovered(cwd, branch, ledger.value.rows);
   const gate = prLaneGate(cwd, check, { branch, base: doc.base, head });
   const summary = {
     head: check.head,
@@ -681,6 +687,9 @@ export async function mergePullRequest(
     lane: gate.lane.lane,
     need: gate.need,
     verification: gate.verification,
+    ...(covered && gate.review === "verified"
+      ? { cover: check.cover, carry: check.cover ? null : check.carry }
+      : {}),
   };
   let unverified: MergeOutcome["unverified"] = null;
   // The bypass covers a missing verdict, never a rejection.

package/src/git/default-base.ts

@@ -0,0 +1,49 @@
+// The default base for patch-ids, author trailers and review lanes. Its own
+// module so the lane (core/policy/lane.ts) and the ledger can both read it
+// without importing each other.
+import { vcsConfig } from "../core/vcs-config";
+import { originHeadRef, resolveRef } from "./rev";
+
+const safeRef = (value: string): boolean => value.length > 0 && !value.startsWith("-");
+
+/**
+ * The PR target of the release track the checkout is on, when the workspace
+ * configures tracks (as `fanout plan` and `stack plan` pick their trunk); a
+ * plain workspace default does not override origin's default branch.
+ */
+const trackTrunk = (cwd: string): string | null => {
+  try {
+    const resolved = vcsConfig("resolve", cwd);
+    if (resolved.ok === false || !resolved.releaseTrack || resolved.releaseTrack.blocking)
+      return null;
+    const target = String(resolved.defaultTargetBranch ?? "").trim();
+    return target && safeRef(target) ? target : null;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * The default base for patch-ids and author trailers: the release track's PR
+ * target (origin's copy, else the local one) when tracks are configured, else
+ * origin's HEAD branch, else the first of origin/main, origin/master, main,
+ * master, origin/develop, develop that exists.
+ */
+export function defaultBase(cwd: string): string | null {
+  const trunk = trackTrunk(cwd);
+  if (trunk)
+    for (const candidate of [`origin/${trunk}`, trunk])
+      if (resolveRef(cwd, candidate)) return candidate;
+  const originHead = originHeadRef(cwd);
+  if (originHead && resolveRef(cwd, originHead)) return originHead;
+  for (const candidate of [
+    "origin/main",
+    "origin/master",
+    "main",
+    "master",
+    "origin/develop",
+    "develop",
+  ])
+    if (resolveRef(cwd, candidate)) return candidate;
+  return null;
+}

package/src/git/rev.ts

@@ -515,6 +515,117 @@ export function resolveRef(cwd: string, ref: string): string | null {
   return line(git(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]));
 }
 
+/** The branch origin's HEAD names (`origin/main`), or null. */
+export function originHeadRef(cwd: string): string | null {
+  return line(git(cwd, ["symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD"]));
+}
+
+/** The top of the working tree, or null outside one. */
+export function worktreeTop(cwd: string): string | null {
+  return line(git(cwd, ["rev-parse", "--show-toplevel"]));
+}
+
+/** Whether git tracks `file` (repo-relative) in the index of the checkout at `top`. */
+export function isTracked(top: string, file: string): boolean {
+  return git(top, ["ls-files", "--error-unmatch", "--", file]).ok;
+}
+
+/**
+ * The files whose own change differs between two versions of a branch: the
+ * judged `from` (forked from `fromFork`) and the current `to` (forked from
+ * `toFork`), compared by exact blob and mode, never by diff text (#334). A
+ * file the branch touches on one side only differs. A file it touches on
+ * both sides is unchanged only when the base left it alone between the forks
+ * and the branch's resulting blob is identical, so a hunk moved within a
+ * file, a re-indent or a base edit in a file the branch touches always
+ * counts. Null when git cannot read either side: the caller fails closed.
+ */
+export function ownChangeDrift(
+  cwd: string,
+  range: { from: string; to: string; fromFork: string; toFork: string },
+): string[] | null {
+  const before = diffRaw(cwd, range.fromFork, range.from);
+  const after = diffRaw(cwd, range.toFork, range.to);
+  if (!before || !after) return null;
+  const judged = new Map(before.map((entry) => [entry.path, entry]));
+  const current = new Map(after.map((entry) => [entry.path, entry]));
+  const same = (a: RawEntry | undefined, b: RawEntry | undefined): boolean =>
+    a !== undefined &&
+    b !== undefined &&
+    a.oldMode === b.oldMode &&
+    a.oldBlob === b.oldBlob &&
+    a.newMode === b.newMode &&
+    a.newBlob === b.newBlob;
+  return [...new Set([...judged.keys(), ...current.keys()])]
+    .filter((file) => !same(judged.get(file), current.get(file)))
+    .toSorted();
+}
+
+/**
+ * Whether the branch's own files are identical at `from` (on `fromBase`) and
+ * `to` (on `toBase`): ownChangeDrift from each head's fork is empty. The
+ * exactness behind every patch-equal carry; false when git cannot tell.
+ */
+export function sameOwnChange(
+  cwd: string,
+  range: { from: string; to: string; fromBase: string; toBase: string },
+): boolean {
+  const fromFork = mergeBase(cwd, range.fromBase, range.from);
+  const toFork = mergeBase(cwd, range.toBase, range.to);
+  if (!fromFork || !toFork) return false;
+  return ownChangeDrift(cwd, { from: range.from, to: range.to, fromFork, toFork })?.length === 0;
+}
+
+/**
+ * The verbatim patch-ids of the non-merge commits of `fork..head` (empty
+ * commits have none) and how many merge commits the range holds: unlike
+ * `--stable`, whitespace counts, so a re-indent is another patch. Diff
+ * options are pinned as in patchId. Null when git fails, or has no
+ * `patch-id --verbatim`: the caller fails closed.
+ */
+export function commitPatchIds(
+  cwd: string,
+  fork: string,
+  head: string,
+): { patchIds: string[]; merges: number } | null {
+  if (!safeArg(fork) || !safeArg(head)) return null;
+  const range = `${fork}..${head}`;
+  const merges = line(git(cwd, ["rev-list", "--count", "--merges", range]));
+  const log = git(
+    cwd,
+    [
+      "log",
+      "--no-merges",
+      "-p",
+      "-U3",
+      "--diff-algorithm=myers",
+      "--indent-heuristic",
+      "--no-color",
+      "--no-ext-diff",
+      "--no-textconv",
+      "--no-renames",
+      "--full-index",
+      "--src-prefix=a/",
+      "--dst-prefix=b/",
+      "--format=commit %H",
+      range,
+      "--",
+    ],
+    { timeoutMs: GIT_TIMEOUTS.worktree },
+  );
+  if (merges === null || !log.ok) return null;
+  if (!log.stdout.trim()) return { patchIds: [], merges: Number(merges) };
+  const ids = git(cwd, ["patch-id", "--verbatim"], { input: log.stdout });
+  if (!ids.ok) return null;
+  return {
+    patchIds: ids.stdout
+      .split("\n")
+      .map((entry) => entry.trim().split(/\s+/u)[0])
+      .filter(Boolean),
+    merges: Number(merges),
+  };
+}
+
 /** Pinned diff options for the review-lane reads: user config never changes them. */
 const LANE_DIFF = [
   "-c",

package/src/hooks/cwd-normalize.ts

@@ -1,16 +1,32 @@
-// `cd <dir> && workit <args>` → `workit --cwd <dir> <args>` (issue #388).
-// On Claude Code the compound does not match a `Bash(workit:*)` allow rule
+// `cd <dir> && workit <args>` → `workit <verb> --cwd <dir> <rest>` (issue #388).
+// On Claude Code the compound does not match a `Bash(workit …)` allow rule
 // (every subcommand must match, and a `cd` outside the working dirs breaks
 // it), so the auto-mode classifier judged it. The rewrite is exact and
 // conservative: one literal directory, one workit call, and only read-only
 // filters after it. Anything else is left alone. Pure string work.
-import { segmentsOf } from "./shell-words";
+//
+// The verb goes first (issue #297): Workit's enumerated host rules, such as
+// `Bash(workit git *)`, cannot match a variable directory before the verb.
+// `--cwd` and `--json` mean the same anywhere before `--` (main.ts
+// parseGlobals), so moving them never changes what runs.
+import { WORKIT_ALLOWED_VERBS } from "./delivery-verbs";
+import { segmentsOf, type Segment } from "./shell-words";
 
 // A directory spelled as one literal word: bare, '…' or "…" with no expansion.
-const COMPOUND =
-  /^\s*cd\s+([A-Za-z0-9_./@%+:,=-]+|'[^'$`\\\n]*'|"[^"$`\\!\n]*")\s*&&\s*(workit(?:\s[\s\S]*)?)$/u;
+const DIR = String.raw`[A-Za-z0-9_./@%+:,=-]+|'[^'$${"`"}\\\n]*'|"[^"$${"`"}\\!\n]*"`;
+const COMPOUND = new RegExp(String.raw`^\s*cd\s+(${DIR})\s*&&\s*(workit(?:\s[\s\S]*)?)$`, "u");
+// `workit` then `--json` / `--cwd <dir>` globals, then the verb.
+const GLOBALS_FIRST = new RegExp(
+  String.raw`^(\s*workit)((?:\s+(?:--json|--cwd(?:=|\s+)(?:${DIR})))+)\s+([a-z][a-z-]*)(?=\s|$)`,
+  "u",
+);
+const VERB_FIRST = /^((?:--json\s+)*)([a-z][a-z-]*)(?=\s|$)/u;
+const VERBS = new Set<string>(WORKIT_ALLOWED_VERBS);
 const FILTERS = new Set(["tail", "head", "grep"]);
 
+const clean = (s: Segment): boolean =>
+  !s.unanalyzable && !s.group && !s.subs?.length && !s.stdin?.length && !s.redirects.length;
+
 // A filter that reads only stdin, so moving the cwd cannot change what it
 // reads: flags and counts for tail/head, one pattern for grep (no -r/-R/-f).
 const stdinOnly = (words: readonly string[]): boolean => {
@@ -22,8 +38,9 @@ const stdinOnly = (words: readonly string[]): boolean => {
 };
 
 /**
- * The command rewritten to `workit --cwd <dir> …`, or null when it is not
- * exactly `cd <literal dir> && workit … [2>&1] [| tail|head|grep …]*`.
+ * The command rewritten to `workit <verb> --cwd <dir> …` (`workit --cwd <dir>
+ * …` for a verb no host rule lists), or null when it is not exactly
+ * `cd <literal dir> && workit … [2>&1] [| tail|head|grep …]*`.
  */
 export const cwdRewrite = (command: string): string | null => {
   const match = COMPOUND.exec(command);
@@ -36,10 +53,27 @@ export const cwdRewrite = (command: string): string | null => {
   const [head, ...filters] = segments;
   if (!head || head.words[0] !== "workit") return null;
   if (head.words.some((w) => w === "--cwd" || w.startsWith("--cwd="))) return null;
-  const clean = (s: (typeof segments)[number]) =>
-    !s.unanalyzable && !s.group && !s.subs?.length && !s.stdin?.length && !s.redirects.length;
   if (!segments.every(clean)) return null;
   if (!segments.slice(0, -1).every((s) => s.pipe)) return null;
   if (!filters.every((s) => FILTERS.has(s.words[0] ?? "") && stdinOnly(s.words))) return null;
-  return `workit --cwd ${dir} ${rest.slice("workit".length).trimStart()}`.trimEnd();
+  const args = rest.slice("workit".length).trimStart();
+  const verb = VERB_FIRST.exec(args);
+  if (!verb?.[2] || !VERBS.has(verb[2])) return `workit --cwd ${dir} ${args}`.trimEnd();
+  const json = verb[1] ? " --json" : "";
+  return `workit ${verb[2]} --cwd ${dir}${json}${args.slice(verb[0].length)}`.trimEnd();
+};
+
+/**
+ * `workit --cwd <dir> <verb> …` (with any `--json` there) rewritten with the
+ * verb first, for a verb the host rules list; null otherwise. Only the words
+ * before the first verb move, and only in a command that is that one call
+ * (no `;`, `&&`, `|`, newline, substitution or redirect).
+ */
+export const verbFirst = (command: string): string | null => {
+  const match = GLOBALS_FIRST.exec(command);
+  const [whole, lead, globals, verb] = match ?? [];
+  if (!whole || !verb || !VERBS.has(verb) || !globals?.includes("--cwd")) return null;
+  const segments = segmentsOf(command);
+  if (segments.length !== 1 || !segments.every(clean)) return null;
+  return `${lead} ${verb}${globals}${command.slice(whole.length)}`;
 };