@@ -139,6 +139,8 @@ pnpm --filter @objectstack/scenarios run-scenarios --driver recorded:/tmp/rec.js
 pnpm --filter @objectstack/scenarios run-scenarios --author-timeout 90       # minutes per authoring turn (default 60)
 pnpm --filter @objectstack/scenarios run-scenarios --author-max-turns 400    # turns per authoring turn, every card (default by tier)
 pnpm --filter @objectstack/scenarios run-scenarios --ask-max-turns 20        # turns per question or operation turn (default 12)
+pnpm --filter @objectstack/scenarios run-scenarios --model sonnet            # the model every turn asks for (default: the login's own)
+pnpm --filter @objectstack/scenarios run-scenarios --author-model opus --ask-model haiku  # build and persona turns apart
 pnpm --filter @objectstack/scenarios run-scenarios --packages workspace      # on this checkout's unreleased packages (default: published)
 ```
 
@@ -167,7 +169,15 @@ Per card and mode the runner writes `docs/qa/platform-checklist/runs/<date>-scen
   is logged in with an API key (the cost ruling on cloud#3600), and the record states the driver, the login, the
   authoring timeout and the turn caps. Every turn records its process: elapsed time, the turn cap it ran under
   (`--max-turns`), and for a turn that did not finish its exit code or signal, whether the runner's timeout killed it,
-  and the end of its stderr. `RecordedDriver` replays a recording, and refuses the three live-driver limits below.
+  and the end of its stderr. `RecordedDriver` replays a recording, and refuses the live-driver limits and models below.
+- **Model** (`driver.ts`): `--model M` passes `claude --model M` on every turn, an alias (`sonnet`) or a name
+  (`claude-sonnet-4-5`); `--author-model` sets the authoring turns (build and iterate) and `--ask-model` the question
+  and operation turns apart, each in place of `--model`. With none, a turn takes the login's default model. Every turn
+  records the model it asked for (`requestedModel`) and the one it was served, read off the stream's init line
+  (`model`); a served name that does not hold the requested one as whole dash-separated parts (`sonnet` is in
+  `claude-sonnet-4-5-20250929`, `opus` is not) is a mismatch (`modelMismatch`). The scorecard's author rows name the
+  served model (`⚠ asked for sonnet` on a mismatch), and its `Run · model` rows count the persona turns per served
+  model (`claude-opus-5-5 ×9 ⚠ 9 not sonnet`).
 - **Turn caps** (`driver.ts`): an authoring turn, build and iterate alike, may take `DEFAULT_AUTHOR_MAX_TURNS` by the
   card's `tier` — `control` 80, `starter` 300, `delivery` 600 — unless `--author-max-turns N` sets one cap for every
   card; a question or operation turn takes 12 unless `--ask-max-turns N` says otherwise. The cap guards a looping turn
 
@@ -22,6 +22,14 @@
  *                        half not measured
  *   --ask-max-turns N    the live driver's turn cap per question or operation
  *                        turn (default 12)
+ *   --model M            the model every live turn asks for, an alias (`sonnet`)
+ *                        or a name (`claude-sonnet-4-5`), as `claude --model`
+ *                        takes it (default: the login's own)
+ *   --author-model M     the model for authoring turns, build and iterate, in
+ *                        place of --model
+ *   --ask-model M        the model for question and operation turns, in place
+ *                        of --model; the record and the scorecard state the
+ *                        model each turn was served, and mark a mismatch
  *   --template F         a verified build (dist/objectstack.json) for template mode
  *   --no-iterate-run     skip the Run half after the iterate (scratch mode)
  *   --out DIR            where records go (default docs/qa/platform-checklist/runs, git-ignored)
@@ -77,6 +85,12 @@ export interface CliArgs {
   authorMaxTurns?: number;
   /** Turns per question or operation turn (`--ask-max-turns`); the driver's default when absent. */
   askMaxTurns?: number;
+  /** The model every live turn asks for (`--model`); the login's default when absent. */
+  model?: string;
+  /** The model an authoring turn asks for (`--author-model`), in place of `model`. */
+  authorModel?: string;
+  /** The model a question or operation turn asks for (`--ask-model`), in place of `model`. */
+  askModel?: string;
   out?: string;
   work?: string;
   createVersion?: string;
@@ -99,6 +113,11 @@ export function parseArgs(argv: readonly string[]): CliArgs {
       if (!Number.isInteger(n) || n <= 0) throw new Error(`${flag} takes a whole number of turns above 0, not \`${raw}\``);
       return n;
     };
+    const model = () => {
+      const raw = val();
+      if (raw.trim() === '' || raw.startsWith('-')) throw new Error(`${flag} takes a model alias or name (sonnet, opus, claude-sonnet-4-5), not \`${raw}\``);
+      return raw;
+    };
     if (flag === '--cards') a.cards = val();
     else if (flag === '--only') a.only = val().split(',');
     else if (flag === '--modes') {
@@ -117,6 +136,9 @@ export function parseArgs(argv: readonly string[]): CliArgs {
     }
     else if (flag === '--author-max-turns') a.authorMaxTurns = turns();
     else if (flag === '--ask-max-turns') a.askMaxTurns = turns();
+    else if (flag === '--model') a.model = model();
+    else if (flag === '--author-model') a.authorModel = model();
+    else if (flag === '--ask-model') a.askModel = model();
     else if (flag === '--out') a.out = val();
     else if (flag === '--work') a.work = val();
     else if (flag === '--create-version') a.createVersion = val();
@@ -135,22 +157,31 @@ export function parseArgs(argv: readonly string[]): CliArgs {
 /** The live driver's limits a run may set: `--author-timeout`, `--author-max-turns`, `--ask-max-turns`. */
 export type DriverLimits = Pick<CliArgs, 'authorTimeoutMin' | 'authorMaxTurns' | 'askMaxTurns'>;
 
-const LIMIT_FLAGS: ReadonlyArray<readonly [keyof DriverLimits, string]> = [
+/** The models a run may ask the live driver for: `--model`, `--author-model`, `--ask-model`. */
+export type DriverModels = Pick<CliArgs, 'model' | 'authorModel' | 'askModel'>;
+
+const LIVE_FLAGS: ReadonlyArray<readonly [keyof (DriverLimits & DriverModels), string]> = [
   ['authorTimeoutMin', '--author-timeout'],
   ['authorMaxTurns', '--author-max-turns'],
   ['askMaxTurns', '--ask-max-turns'],
+  ['model', '--model'],
+  ['authorModel', '--author-model'],
+  ['askModel', '--ask-model'],
 ];
 
-export function makeDriver(spec: string, opts: DriverLimits = {}): AgentDriver {
+export function makeDriver(spec: string, opts: DriverLimits & DriverModels = {}): AgentDriver {
   if (spec === 'claude') {
     return new ClaudeCodeDriver({
       ...(opts.authorTimeoutMin !== undefined ? { authorTimeoutMs: opts.authorTimeoutMin * 60_000 } : {}),
       ...(opts.authorMaxTurns !== undefined ? { authorMaxTurns: opts.authorMaxTurns } : {}),
       ...(opts.askMaxTurns !== undefined ? { askMaxTurns: opts.askMaxTurns } : {}),
+      ...(opts.model !== undefined ? { model: opts.model } : {}),
+      ...(opts.authorModel !== undefined ? { authorModel: opts.authorModel } : {}),
+      ...(opts.askModel !== undefined ? { askModel: opts.askModel } : {}),
     });
   }
   if (spec.startsWith('recorded:')) {
-    const given = LIMIT_FLAGS.filter(([key]) => opts[key] !== undefined).map(([, flag]) => flag);
+    const given = LIVE_FLAGS.filter(([key]) => opts[key] !== undefined).map(([, flag]) => flag);
     if (given.length) throw new Error(`${given.join(', ')} ${given.length === 1 ? 'applies' : 'apply'} to the live driver only: a replay re-reads each turn as it was recorded`);
     return RecordedDriver.fromFile(spec.slice('recorded:'.length));
   }
@@ -185,7 +216,9 @@ export async function main(argv: readonly string[]): Promise<number> {
     `driver: ${info.driver} ${info.version ?? ''} · login: ${info.authMethod ?? 'n/a'} · API-billed: no` +
       (info.authorTimeoutMs !== undefined ? ` · author timeout: ${minutesText(info.authorTimeoutMs)}` : '') +
       (info.authorMaxTurns ? ` · author max turns: ${Object.entries(info.authorMaxTurns).map(([tier, n]) => `${tier} ${n}`).join(', ')}` : '') +
-      (info.askMaxTurns !== undefined ? ` · ask max turns: ${info.askMaxTurns}` : ''),
+      (info.askMaxTurns !== undefined ? ` · ask max turns: ${info.askMaxTurns}` : '') +
+      (info.authorModel ? ` · author model: ${info.authorModel}` : '') +
+      (info.askModel ? ` · ask model: ${info.askModel}` : ''),
   );
 
   // Built and packed once, before the first card: every scaffold of this run installs the same tarballs.
 
@@ -78,6 +78,10 @@ export interface DriverInfo {
   authorMaxTurns?: Record<ScenarioTier, number>;
   /** The live driver's turn cap per question or operation turn. */
   askMaxTurns?: number;
+  /** The model the live driver asks for on an authoring turn (`--model` / `--author-model`); absent ⇒ the login's default. */
+  authorModel?: string;
+  /** The model the live driver asks for on a question or operation turn (`--model` / `--ask-model`); absent ⇒ the login's default. */
+  askModel?: string;
 }
 
 export interface AgentDriver {
@@ -155,8 +159,35 @@ export interface ClaudeCodeDriverOptions {
   authorTimeoutMs?: number;
   /** Wall-clock budget per question or operation, ms; default 5 min. */
   askTimeoutMs?: number;
-  /** Optional model alias passed as `--model` (the login's default otherwise). */
+  /** The model passed as `--model` on every turn (an alias such as `sonnet`, or a full name); the login's default otherwise. */
   model?: string;
+  /** The model for an authoring turn (build and iterate), in place of {@link model}. */
+  authorModel?: string;
+  /** The model for a question or operation turn, in place of {@link model}. */
+  askModel?: string;
+}
+
+/** `claude-sonnet-4-5-20250929[1m]` → `['claude', 'sonnet', '4', '5', '20250929']`: the name's parts, the context-size suffix dropped. */
+const modelParts = (name: string): string[] => name.toLowerCase().replace(/\[[^\]]*\]$/, '').split('-').filter(Boolean);
+
+/**
+ * Was the turn served the model it asked for? The CLI takes an alias
+ * (`sonnet`) or a name (`claude-opus-4-1`) and the stream's init line names
+ * the model it resolved to (`claude-sonnet-4-5-20250929`), so a turn is served
+ * as asked when the served name holds the requested one as a whole run of its
+ * dash-separated parts — `sonnet` and `claude-sonnet-4-5` in
+ * `claude-sonnet-4-5-20250929`, never `opus` in it. Any other answer, an alias
+ * that names no model family (`default`, `opusplan`) included, is a mismatch the
+ * scorecard shows beside both names, for the reader to judge.
+ */
+export function servedAsRequested(requested: string, served: string): boolean {
+  const want = modelParts(requested);
+  const got = modelParts(served);
+  if (want.length === 0) return false;
+  for (let i = 0; i + want.length <= got.length; i++) {
+    if (want.every((part, j) => got[i + j] === part)) return true;
+  }
+  return false;
 }
 
 interface CliRun {
@@ -297,6 +328,14 @@ export class ClaudeCodeDriver implements AgentDriver {
     return this.opts.askMaxTurns ?? DEFAULT_ASK_MAX_TURNS;
   }
 
+  private get authorModel(): string | undefined {
+    return this.opts.authorModel ?? this.opts.model;
+  }
+
+  private get askModel(): string | undefined {
+    return this.opts.askModel ?? this.opts.model;
+  }
+
   info(): DriverInfo {
     return {
       driver: 'claude-code-cli',
@@ -306,12 +345,14 @@ export class ClaudeCodeDriver implements AgentDriver {
       authorTimeoutMs: this.authorTimeoutMs,
       authorMaxTurns: Object.fromEntries(SCENARIO_TIERS.map((t) => [t, this.authorMaxTurns(t)])) as Record<ScenarioTier, number>,
       askMaxTurns: this.askMaxTurns,
+      ...(this.authorModel ? { authorModel: this.authorModel } : {}),
+      ...(this.askModel ? { askModel: this.askModel } : {}),
     };
   }
 
-  private base(maxTurns: number): string[] {
+  private base(maxTurns: number, model: string | undefined): string[] {
     const a = ['--output-format', 'stream-json', '--verbose', '--max-turns', String(maxTurns)];
-    if (this.opts.model) a.push('--model', this.opts.model);
+    if (model) a.push('--model', model);
     return a;
   }
 
@@ -320,16 +361,17 @@ export class ClaudeCodeDriver implements AgentDriver {
     writeFileSync(empty, JSON.stringify({ mcpServers: {} }));
     try {
       const maxTurns = this.authorMaxTurns(task.tier);
+      const model = this.authorModel;
       const args = [
         '-p',
-        ...this.base(maxTurns),
+        ...this.base(maxTurns, model),
         '--mcp-config', empty, '--strict-mcp-config',
         '--permission-mode', 'acceptEdits',
         '--allowedTools', 'Bash', 'Read', 'Edit', 'Write', 'Glob', 'Grep', 'Skill',
       ];
       const run = await runCli(this.bin, args, task.cwd, task.prompt, this.authorTimeoutMs);
       const turn = parseStreamJson(run.stdout);
-      turn.meta.process = { ...run.process, maxTurns };
+      turn.meta.process = { ...run.process, maxTurns, ...(model ? { requestedModel: model } : {}) };
       if (turn.meta.resultSubtype === undefined) turn.meta.resultSubtype = noResult(run.process);
       return { turn, files: snapshotSources(task.cwd) };
     } finally {
@@ -349,10 +391,11 @@ export class ClaudeCodeDriver implements AgentDriver {
     );
     try {
       const maxTurns = this.askMaxTurns;
-      const args = ['-p', ...this.base(maxTurns), '--mcp-config', cfg, '--strict-mcp-config', '--allowedTools', 'mcp__app'];
+      const model = this.askModel;
+      const args = ['-p', ...this.base(maxTurns, model), '--mcp-config', cfg, '--strict-mcp-config', '--allowedTools', 'mcp__app'];
       const run = await runCli(this.bin, args, dir, task.prompt, this.opts.askTimeoutMs ?? 5 * 60_000);
       const turn = parseStreamJson(run.stdout);
-      turn.meta.process = { ...run.process, maxTurns };
+      turn.meta.process = { ...run.process, maxTurns, ...(model ? { requestedModel: model } : {}) };
       if (turn.meta.resultSubtype === undefined) turn.meta.resultSubtype = noResult(run.process);
       return turn;
     } finally {
 
@@ -44,7 +44,7 @@ import {
   type ScenarioArtifactScore,
 } from '../score/index.js';
 import type { AppHarness, PersonaAccount } from './app.js';
-import type { AgentDriver, StepRef } from './driver.js';
+import { servedAsRequested, type AgentDriver, type StepRef } from './driver.js';
 import { citationLabels, namespaceOfArtifact, namespacedScenario, permissionSetName, templateHostName } from './namespace.js';
 import { agentSetOf, clockDates, observeOperation, observeProbe, probeCall, touchedRowId, type Row } from './observe.js';
 import type { CommandResult } from './project.js';
@@ -95,7 +95,12 @@ export interface TurnSummary {
   /** The turn cap the CLI process ran under (`meta.process`): `numTurns` of `maxTurns`. */
   maxTurns?: number;
   toolCalls: number;
+  /** The model the turn was served (the stream's `meta.model`); absent when its stream named none. */
   model?: string;
+  /** The model the driver asked for (`--model`, `meta.process`); absent ⇒ the login's default. */
+  requestedModel?: string;
+  /** The served model is not the requested one ({@link servedAsRequested}); only when both are known. */
+  modelMismatch?: true;
   /** Wall-clock time of the CLI process, when the driver ran one (`meta.process`). */
   elapsedMs?: number;
   // What a turn that did not finish leaves to say why (`meta.process`):
@@ -204,6 +209,8 @@ const summarize = (t: ParsedTurn): TurnSummary => {
     ...(t.meta.numTurns !== undefined ? { numTurns: t.meta.numTurns } : {}),
     ...(p?.maxTurns !== undefined ? { maxTurns: p.maxTurns } : {}),
     ...(t.meta.model ? { model: t.meta.model } : {}),
+    ...(p?.requestedModel ? { requestedModel: p.requestedModel } : {}),
+    ...(p?.requestedModel && t.meta.model && !servedAsRequested(p.requestedModel, t.meta.model) ? { modelMismatch: true as const } : {}),
     toolCalls: t.toolCalls.length,
     ...(p ? { elapsedMs: p.elapsedMs } : {}),
     ...(p && !finished(t)