@brainervirus/workit-core 8.25.0 → 8.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-core",
-  "version": "8.25.0",
+  "version": "8.26.0",
   "private": false,
   "description": "Workit shared core — task, policy, evidence, review, decision, worker, and writer state for agentic coding workflows",
   "keywords": [

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; 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
+   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/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,7 +9,8 @@ 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.

package/skills/workit-ship/SKILL.md

@@ -51,7 +51,7 @@ the same check. Fix round and recheck both failed: a decider (workit-fanout).
    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 (workit-review), on Claude Code `model: sonnet` when focused. 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
+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 (workit-review), 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

package/src/core/role-models.ts

@@ -0,0 +1,209 @@
+// Role models (#395): the model and effort a role runs on, per host.
+//
+// `models.roles` in workspaces.json (top level = global default, per
+// workspace = override, nested workspaces inherit like `fanout.tierModels`):
+//
+//   { "decider": { "claude_code": { "model": "fable", "effort": "high" } },
+//     "implementer": { "hard": { "claude_code": "opus" }, "standard": … },
+//     "verifier": { "claude_code": "sonnet", "default": "…" } }
+//
+// A role maps to a per-host object (keys: claude_code, opencode, codex,
+// cursor, pi, default) whose values are a model name or `{ model, effort? }`.
+// A bare model name or `{ model, effort? }` applies to every host. The
+// implementer takes one such value per fanout tier. `fanout.tierModels` is
+// read as the implementer tiers (a model name per tier and host, no effort);
+// within one workspace `models.roles` wins over it. Everything is read
+// leniently: a malformed entry is skipped and reported (`roleModelIssues`),
+// never an error. Claude Code has built-in defaults; other hosts inherit
+// their own default model when nothing is configured.
+import { hostFamily, modelSources } from "./workspaces";
+
+export const MODEL_ROLES = [
+  "decider",
+  "implementer",
+  "verifier",
+  "reviewer",
+  "explore",
+  "babysit",
+] as const;
+export type ModelRole = (typeof MODEL_ROLES)[number];
+export const MODEL_TIERS = ["mundane", "standard", "hard"] as const;
+export type ModelTier = (typeof MODEL_TIERS)[number];
+
+export type RoleSelector = { role: ModelRole; tier?: ModelTier };
+export type RoleModel = { model: string; effort: string | null; source: string };
+
+const HOST_KEYS = new Set([
+  "claude_code",
+  "opencode",
+  "codex",
+  "codex_cli",
+  "codex_desktop",
+  "cursor",
+  "pi",
+  "default",
+]);
+
+const BUILT_IN_CLAUDE_CODE: Record<string, { model: string; effort?: string }> = {
+  decider: { model: "fable", effort: "high" },
+  "implementer.hard": { model: "opus" },
+  "implementer.standard": { model: "sonnet" },
+  "implementer.mundane": { model: "haiku" },
+  verifier: { model: "sonnet" },
+  reviewer: { model: "opus" },
+  explore: { model: "haiku" },
+  babysit: { model: "haiku" },
+};
+
+const isObject = (value: unknown): value is Record<string, unknown> =>
+  !!value && typeof value === "object" && !Array.isArray(value);
+const name = (value: unknown): string | null =>
+  typeof value === "string" && value.trim() ? value.trim() : null;
+
+/** `"model"` or `{ model, effort? }` as a model and effort; null when it names no model. */
+const leaf = (value: unknown): { model: string; effort: string | null } | null => {
+  const text = name(value);
+  if (text) return { model: text, effort: null };
+  if (!isObject(value)) return null;
+  const model = name(value.model);
+  return model ? { model, effort: name(value.effort) } : null;
+};
+
+const isFlat = (value: unknown): boolean =>
+  typeof value === "string" || (isObject(value) && Object.hasOwn(value, "model"));
+
+/** The value for `host` in a per-host object (or a flat value for every host). */
+const forHost = (value: unknown, host: string | null) => {
+  if (isFlat(value)) return leaf(value);
+  if (!isObject(value)) return null;
+  const family = host ? hostFamily(host) : null;
+  for (const key of [family, host, "default"])
+    if (key && Object.hasOwn(value, key)) {
+      const found = leaf(value[key]);
+      if (found) return found;
+    }
+  return null;
+};
+
+const rolesOf = (models: unknown): Record<string, unknown> | null =>
+  isObject(models) && isObject(models.roles) ? models.roles : null;
+
+/**
+ * The model and effort for a role on a host, or null (the host's own default
+ * applies). Order: the selected workspace, each enclosing workspace, the
+ * global default (each: `models.roles`, then `fanout.tierModels` for an
+ * implementer tier), then Claude Code's built-in defaults.
+ */
+export const resolveRoleModel = (
+  cwd: string,
+  selector: RoleSelector,
+  host: string | null,
+  dir?: string,
+): RoleModel | null => {
+  const { role, tier } = selector;
+  for (const source of modelSources(cwd, dir)) {
+    const where = source.global ? "the global default" : `workspace ${source.name}`;
+    const roles = rolesOf(source.models);
+    const configured = roles && Object.hasOwn(roles, role) ? roles[role] : undefined;
+    const fromRoles =
+      role === "implementer"
+        ? tier && isObject(configured) && Object.hasOwn(configured, tier)
+          ? forHost(configured[tier], host)
+          : null
+        : forHost(configured, host);
+    if (fromRoles) return { ...fromRoles, source: `models.roles in ${where}` };
+    if (role === "implementer" && tier && isObject(source.tierModels)) {
+      const fromTiers = Object.hasOwn(source.tierModels, tier)
+        ? forHost(source.tierModels[tier], host)
+        : null;
+      if (fromTiers)
+        return { model: fromTiers.model, effort: null, source: `fanout.tierModels in ${where}` };
+    }
+  }
+  if (host && hostFamily(host) === "claude_code") {
+    const builtIn = BUILT_IN_CLAUDE_CODE[tier ? `${role}.${tier}` : role];
+    if (builtIn)
+      return { model: builtIn.model, effort: builtIn.effort ?? null, source: "built-in" };
+  }
+  return null;
+};
+
+/**
+ * The implementer model when a host's agent serves every fanout tier (a Codex
+ * agent file, a Pi worker): set only when all three tiers resolve to the same
+ * model and effort, else null (the spawn or session decides per slice).
+ */
+export const uniformImplementerModel = (
+  cwd: string,
+  host: string | null,
+  dir?: string,
+): RoleModel | null => {
+  const tiers = MODEL_TIERS.map((tier) =>
+    resolveRoleModel(cwd, { role: "implementer", tier }, host, dir),
+  );
+  const [first] = tiers;
+  return first && tiers.every((t) => t?.model === first.model && t.effort === first.effort)
+    ? first
+    : null;
+};
+
+/** Every selector `models show` lists, in role order. */
+export const ROLE_SELECTORS: RoleSelector[] = MODEL_ROLES.flatMap((role): RoleSelector[] =>
+  role === "implementer" ? MODEL_TIERS.map((tier) => ({ role, tier })) : [{ role }],
+);
+
+const valueIssues = (where: string, value: unknown, out: string[]): void => {
+  if (isFlat(value)) {
+    if (!leaf(value)) out.push(`${where}.model: not a model name; ignored`);
+    if (isObject(value) && value.effort !== undefined && !name(value.effort))
+      out.push(`${where}.effort: not an effort name; ignored`);
+    return;
+  }
+  if (!isObject(value)) {
+    out.push(`${where}: not a model name or a per-host object; ignored`);
+    return;
+  }
+  for (const [host, entry] of Object.entries(value)) {
+    if (!HOST_KEYS.has(host)) out.push(`${where}.${host}: unknown host; ignored`);
+    else {
+      if (!leaf(entry)) out.push(`${where}.${host}.model: not a model name; ignored`);
+      if (isObject(entry) && entry.effort !== undefined && !name(entry.effort))
+        out.push(`${where}.${host}.effort: not an effort name; ignored`);
+    }
+  }
+};
+
+/**
+ * What `models.roles` holds that Workit ignores (an unknown role, tier or
+ * host, a value that is not a model name or effort), across the global
+ * default and every workspace matching cwd. `workit doctor` and `workit grant
+ * show` report them.
+ */
+export const roleModelIssues = (cwd: string, dir?: string): string[] => {
+  const issues: string[] = [];
+  for (const source of modelSources(cwd, dir)) {
+    if (source.models === undefined) continue;
+    const base = `${source.global ? "global default" : `workspace ${source.name}`} models.roles`;
+    if (
+      !isObject(source.models) ||
+      (source.models.roles !== undefined && !rolesOf(source.models))
+    ) {
+      issues.push(`${base} is not an object; ignored`);
+      continue;
+    }
+    for (const [role, value] of Object.entries(rolesOf(source.models) ?? {})) {
+      const where = `${base}.${role}`;
+      if (!(MODEL_ROLES as readonly string[]).includes(role))
+        issues.push(`${base}.${role}: unknown role; ignored`);
+      else if (role === "implementer") {
+        if (!isObject(value)) issues.push(`${where}: not an object keyed by tier; ignored`);
+        else
+          for (const [tier, entry] of Object.entries(value))
+            if (!(MODEL_TIERS as readonly string[]).includes(tier))
+              issues.push(`${where}.${tier}: unknown tier; ignored`);
+            else valueIssues(`${where}.${tier}`, entry, issues);
+      } else valueIssues(where, value, issues);
+    }
+  }
+  return issues;
+};

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

@@ -20,7 +20,7 @@
 // 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. */
@@ -185,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 =
@@ -222,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,
@@ -251,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